งานของคุณ: รับสายป้อนข้อมูลตรวจสอบว่าการเป็นตัวแทนไบนารีของสตริงนั้นไม่มี 4 1s หรือ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 1s หรือ0s จะนับเป็นการวิ่งสองครั้ง, 6 ครั้งในแถวนับเป็นการวิ่งสามครั้ง ฯลฯ
การป้อนข้อมูลจะเป็นสตริงหรืออาร์เรย์อักขระไม่ใช่รูปแบบอื่นใด
คุณอาจเขียนโปรแกรมหรือฟังก์ชั่นที่สมบูรณ์
คุณต้องให้การเป็นตัวแทนไบนารีของรหัสของคุณในคำตอบของคุณ

ขอให้โชคดีคะแนนต่ำสุดชนะ!

สคริปต์นี้อาจช่วยคุณในการท้าทายวางโค้ดของคุณในอินพุทและจะให้รหัสไบนารี่แก่คุณความยาวการลงโทษและคะแนนรวมหากคุณใช้ UTF-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>

Expand snippet

— พาเวล
แหล่งที่มา

1

ผมค่อนข้างแน่ใจว่าข้อมูลโค้ดเป็นรถเช่นผมเห็นที่ระบุไว้และที่เป็น|| 0111110001111100

— Ørjan Johansen

ถูกต้องจุดดี หนึ่งวินาที.

— Pavel

2

คงจะสนุกมากขึ้นถ้างานหาคะแนนของสตริง

— Adám

1

@ โจนาธานอัลเลนดีวิธีที่ฉันตั้งใจมันทำ แต่เมื่อพิจารณาเพิ่มเติมฉันไม่เห็นเหตุผลที่แท้จริงดังนั้นฉันจะเปลี่ยนมัน

— Pavel

1

@Pavel การให้คะแนนไม่ได้ขึ้นอยู่กับจำนวนไบต์หากมีบทลงโทษ สิ่งนี้ทำให้มันเป็น [code-challenge] ไม่ใช่ [code-golf] จากแท็กวิกิ: "หากความยาวซอร์สโค้ดไม่ใช่เกณฑ์การให้คะแนนหลักให้พิจารณาใช้แท็กอื่นแทน" TL; DR เนื่องจากคะแนนจริง = / = จำนวนไบต์ของโปรแกรมและรหัสที่สั้นที่สุดไม่ได้หมายถึงการได้คะแนนที่ดีที่สุดไม่ใช่ [code-golf]

— mbomb007

19

เยลลี่ , 18 ไบต์ + 0 บทลงโทษ = 18

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

ส่งคืน1ถ้าไม่มีสตริงบิตที่มีความยาวเท่ากับ4หรือมากกว่าในการแสดงคำแบบ 8 บิตของอินพุตสตริง ASCII และ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

อย่างไร?

เทคนิคในการหลีกเลี่ยงความเสียหายคือ:

เพื่อหลีกเลี่ยง monad "แปลงจากอักขระเป็นลำดับ" Oโดยการแปลงตัวเลข79เป็นอักขระที่ใช้Ọแล้วตามด้วย "การประเมินโค้ด Jelly กับอินพุต", v.
เพื่อหลีกเลี่ยงการแปลงโดยตรงเป็นไบนารี่โดยใช้B( 0x42, 1000010) โดยทางเลือกแบบสองไบต์อย่างง่ายb2โดยใช้การแปลงเบสไดแด็กทั่วไป
เพื่อหลีกเลี่ยงตัวเลือกปกติบางอย่างสำหรับการนับจำนวนการทำงานของบิตที่เท่ากัน - ตัวเลือกแรกคือ "ส่วนที่ซ้อนทับกันทั้งหมดของความยาวที่กำหนด", ṡ( 0xF5หรือ11110101) ตัวเลือกที่สองอาจเป็นการใช้ "รายการย่อยทั้งหมด" Ẇ( 0xCFหรือ11001111)
วิธีแก้ปัญหาที่ฉันใช้ก่อนหน้าปัจจุบันคือการเพิ่ม (ระหว่างองค์ประกอบที่ต่อเนื่องกัน) ด้วยI(การวางศูนย์และสิ่งที่อยู่บนฐานที่เท่ากัน) และเพื่อค้นหาการเกิดขึ้นของสามศูนย์ในแถวใด ๆ ต้องการทำเช่นนั้นผมแปลงศูนย์ทั้งหมดเพื่อคนโดยการใช้ฟังก์ชั่นทวินามด้วย2cเช่น2cx - ทำ-1s กลายเป็น0เอ1s กลายเป็น2s และ0s กลายเป็น1s; ว่าวิธีการรหัสสามารถมองหาเกิดขึ้นครั้งแรกของรายการย่อยกับ[1,1,1] แต่เป็นวิธีที่สั้นก็เห็นได้ชัด - เพื่อเลียนแบบการกระทำของ "ทุกชิ้นที่ทับซ้อนกันของความยาวที่กำหนด" ที่หนึ่งสามารถใช้4 -wise ที่ทับซ้อนกันกับคู่ลดบาง หากสิ่งนี้ถูกดำเนินการด้วยการบวกมันจะนับs ดังนั้นใด ๆหรือการมีอยู่เป็นตัวบ่งชี้ที่จะส่งกลับค่าความจริง ปัญหาที่นี่คือขั้นตอนที่ชัดเจนต่อไปจะเป็นที่จะใช้โมดูโล4ของที่จะนำและรายการที่เท่าเทียมในขณะที่ออกค่าที่เป็นไปได้อื่น ๆ ( , และ) ไม่เปลี่ยนแปลง แต่มีw111
ṡ<dyad>4\+4\10404123+\%4\%ภายในซึ่งมีบิตค่า 010111 0000 100100. เพื่อหลีกเลี่ยงโทษว่าตัวเลขที่จะถูกแปลงทั้งหมดไปยังฐาน4กับb4(การทำแผนที่0ไป[0], 1ไป[1], 2ไป[2], 3ไป[3]และ4ไป[1,0]) Fและทั้งหมดนี้คือรายการบี้กับ ตอนนี้การทดสอบที่ผ่านมาเป็นเพียงการตรวจสอบว่ามีผู้ใด0ในรายการทำได้โดยตรงกับ Ạmonad

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นำหน้าเลขศูนย์นำหน้าจะอยู่ตรงนั้นและอีกอันหนึ่งและเลขศูนย์หน้าพวกมัน เนื่องจากไม่มี ASCII ที่พิมพ์ได้มีศูนย์นำสามค่าตรงจึงไม่จำเป็นต้องทิ้งบิตพิเศษเหล่านี้ก่อนที่จะเช็คที่เหลือ

— Jonathan Allan
แหล่งที่มา

ฉันสมมติว่าคุณสามารถเพิ่มลบล้างหรือสิ่งที่คล้ายกับการปฏิบัติตามค่าที่คุณส่งออก / ผลตอบแทนสำหรับความจริงและความเท็จจะต้องสอดคล้องซึ่งฉันตีความว่า "มูลค่าเดียวกันในแต่ละครั้งสำหรับความจริง" และเหมือนกันสำหรับเท็จ นอกจากนี้จริง / เท็จของคุณอยู่ตรงข้ามกับคำถาม

— Emigna

ฉันเพิ่งถามเกี่ยวกับเรื่องนั้น - ตอนที่ฉันอ่านมัน (หลายชั่วโมงก่อน) ฉันเอา "ค่าที่คุณส่งออก / ผลตอบแทนสำหรับความจริงและความเท็จจะต้องสอดคล้องกัน" หมายความว่าเราสามารถส่งออกได้ทั้งสองทางตราบใดที่มันยังคงเหมือนเดิมระหว่างการวิ่ง ...

— Jonathan Allan

แน่นอนฉันสามารถบันทึกบางอย่างเช่นกันถ้าฉันไม่ต้องทำอย่างนั้น คะแนนต่ำมากเมื่อใช้เวอร์ชั่นใหม่ที่ฉันกำลังใช้งาน ฉันหวังว่าคุณจะเป็นคนที่ตีความถูกต้อง :)

— Emigna

ทีนี้ฉันได้คำต่อท้ายสองไบต์ที่ใช้กลอุบายให้ทั้งสองแบบในลักษณะเดียวกับตัวอย่างและค่าที่สอดคล้องกันอย่างเคร่งครัด0และ1ถ้าจำเป็นต้องเป็น

— Jonathan Allan

ดี รอคอยที่จะเห็นว่าคุณทำมันได้อย่างไร ฉันลงถึง 15 ถ้าฉันไม่สนใจ demerits :)

— Emigna

12

Java 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

— โผล่
แหล่งที่มา

เคล็ดลับดีกับการขึ้นบรรทัดใหม่ การนับ00000/ 11111เป็นสองการวิ่ง000000/ 111111เป็นสามและอื่น ๆ ฉันนับการวิ่งทั้งหมด 101 ครั้ง

— ETHproductions

@ETHproductions คงที่

— Poke

สิ่งนี้น่าจะชนะเพราะ Java ไม่เคยมีความหมายสำหรับเรื่องนี้

— Christopher

10

APL (Dyalog Classic) , 26 + 1 × 10 = 36 ไบต์

หมายเหตุ

มี 4-run 1s หนึ่งครั้ง ต้องใช้⎕IO←0ซึ่งเป็นค่าเริ่มต้นในหลาย ๆ ระบบ โปรดทราบว่าสิ่งนี้จะต้องทำงานกับล่ามแบบคลาสสิกเพื่อให้สตริงมีหนึ่งไบต์ต่ออักขระ

ส่ง

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

ลองออนไลน์!

แหล่งไบนารี

_{^{00110001101011001001110010110010100101110101110010111001001010001101011100110100010111001010100010}} 1111_{^{0010111011101010111010101100101001101110101010100010011011001100010011000110001100010001000101001010001101}}

คำอธิบาย

⍞ พรอมต์สำหรับการป้อนสตริง

11 ⎕DR แปลงเป็นบูลีน1บิต ( 1 ) D ata R epresentation

⊂ ล้อมรอบเพื่อให้เราสามารถนำสิ่งต่าง ๆ ไปใช้กับมัน

(... ) ⍷¨ ตัวบ่งชี้ไบนารีที่แต่ละลำดับต่อไปนี้เริ่มต้น ...

× ลงชื่อ (ไม่ต้องใช้ข้อมูลไบนารี แต่รวมเป็น spacer เพื่อแยกการรัน)

4 \¨ ขยาย (คัดลอก) แต่ละอันยาวสี่

⍳ จำนวนเต็มสูงสุด

≢ นับของ

⍬⍬ รายการประกอบด้วยรายการตัวเลขสองรายการที่ว่างเปล่า

∊ เกณฑ์ (แบน)

⌈\ สะสมสูงสุด

⌽ ถอยหลัง

⊃ เลือกแรก

1 ≠ แตกต่างจากอะไร (เช่นไม่)

เดินผ่าน

เราจะป้อน "48" เพื่อรุ่นยกเลิก-de-runned ungolfed ~ ∨/ ∊ (0 0 0 0)(1 1 1 1) ⍷¨ ⊂ 11 ⎕DR ⍞:

11 ⎕DR ⍞ แปลง "48" เป็น 0 0 1 1 0 1 0 0 0 0 1 1 1 0 0 0 (เช่น Dec 52 56, Hex 34 38)

(0 0 0 0)(1 1 1 1) ⍷¨ ⊂ค้นหาจุดเริ่มต้นของ 0-run และ 1-run (0 0 0 0 0 0 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 0 0 0)

∨/ ∊ดูว่ามีความจริงใด ๆ (เช่นวิ่งใด ๆ ); 1

~ปฏิเสธว่า 0

— อาดัม
แหล่งที่มา

4

เยลลี่ 28 + 140 demerits = 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

แผ่รายการ ( F) ให้เป็นสตริงไบนารีรวมของการเข้ารหัส ASCII และรันไทม์เข้ารหัสเอาต์พุต ( Œ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 ครั้ง ใน UTF-8 มีขนาด 28 ไบต์ แต่มีการฝ่าฝืนเพียง 14 ครั้งเท่านั้น

— walpen
แหล่งที่มา

3

05AB1E , 22 + 3 * 10 = 52

บทลงโทษที่บันทึกไว้ 2 รายการยืมคำแนะนำเดลต้าจากคำตอบ Jelly ของ Jonathan Allan

$Ç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

3 วิ่งมาจากโทษvy¦}ที่ใช้ในการตัดไบต์แรกในแต่ละสายไบนารี แต่ก็ยังคงถูกกว่า 4 €¦วิ่งเราต้องการได้รับจากที่สั้นกว่า

— Emigna
แหล่งที่มา

@ โจนาธานอัลลัน: ฉันพูดถึงมันเล็กน้อยในตอนท้าย (แต่ไม่ได้อยู่ในรายละเอียด) แต่น่าเสียดายที่การแสดงเลขฐานสอง€ใน CP-1252 นั้น10000000มีโทษ 4 ตัว

— Emigna

อ่าคุณทำ! ... และรหัส Python ของฉันสำหรับการเป็นตัวแทนนั้นไม่ถูกต้องเนื่องจากฉันใส่# coding: cp1252ที่ด้านบน> _ <

— Jonathan Allan

3

Perl , 33 + 160 = 193

รหัส 32 ไบต์ + 1 ไบต์สำหรับการ-nตั้งค่าสถานะ

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

(ต้องป้อนข้อมูลโดยไม่ขึ้นบรรทัดใหม่ขั้นสุดท้าย ลิงก์ลองใช้ออนไลน์มีการ-lตั้งค่าสถานะเพื่อลบบรรทัดใหม่ แต่สำหรับอินพุตเดียวไม่จำเป็นต้องใช้)

ลองออนไลน์!

การถ่ายโอนข้อมูล xxd:

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บันทึก ~ 8 คะแนนมากกว่าการใช้-pและ$_=เนื่องจากpมีการเรียกใช้ 40ในขณะที่nไม่มี
+ในฐานะที่เป็นตัวคั่นสำหรับ regex บันทึกการทำงานของ1ที่อยู่ใน/ที่อยู่ใน
ทำสองขั้นตอนแทนหนึ่งด้วยการ!~บันทึกสองการทำงาน (~เป็น01111110แบบไบนารี)
unpack"B*"ค่อนข้างแพง (4 วิ่ง) แต่ฉันไม่สามารถหาได้ถูกกว่า (ฐานการแก้ปัญหาบนordจะยิ่งแพง)

— Dada
แหล่งที่มา

3

PHP, 98 + 270 = 368 ไบต์

ฉันต้องการใช้แนวทางที่แตกต่างจากที่ติตัสเสนอและจบลงด้วยโปรแกรมที่ยาวกว่าเล็กน้อย แต่ถูกลงโทษน้อยกว่า

$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 ไบต์)

— roberto06
แหล่งที่มา

2

PHP, 86 ไบต์ + 370 = 456

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

สร้างสตริงไบนารีและใช้ regex เพื่อตรวจจับลายเส้น เอาท์พุท1สำหรับความจริง; ว่างเปล่าสำหรับเท็จ

echo '<string>' | php -nR '<code>'ทำงานด้วย

การปรับแต่ง

backreferences บันทึก 100 บทลงโทษสำหรับ 3 ไบต์ (-97 คะแนน)

แนวคิดที่ถูกทิ้งร้าง

join(array_map(str_split())) จะเสียค่าใช้จ่าย 31 ไบต์และ 90 โทษ
และ<?=/ $argv[1]แทนecho/ $argnราคาอีก 2 + 40
str_pad(decbin())มีค่าใช้จ่ายสูงกว่าsprintf: 7 ไบต์และ 110 บทลงโทษ
strtr บันทึก 80 โทษสำหรับ 13 ไบต์พิเศษ แต่การอ้างอิงกลับดีกว่า
การจัดกลุ่มการอ้างอิงกลับ#(.)\\1{3}จะบันทึก 3 ไบต์ แต่เพิ่มการลงโทษ 10 ครั้ง
foreach ค่าใช้จ่าย 3 + 50
ไม่สามารถบันทึกชื่อตัวแปรได้
ต้นทุนการบัฟเฟอร์การส่งออก 42 + 120

— ติตัส
แหล่งที่มา

เพิ่ม§ที่สำหรับfor(§; -9

— Christoph

2

MATL, 16 ไบต์ + 60 = 76 ไบต์

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

ลองใช้ที่MATL Online

— Suever
แหล่งที่มา

2

JavaScript (ES8), 91 ไบต์ + 430 บทลงโทษ = 521 รวม

ออกจะนี้1สำหรับtrueและสำหรับ0false

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

ขยายตัวอย่างข้อมูล

— มีขนดก
แหล่งที่มา

padStartไม่ได้อยู่ใน ES6

— Neil

Damnit! ฉันลืมที่จะเปลี่ยนเป็น ES8 ทุกครั้งที่ฉันใช้มัน (เช่นเดียวกับ ES7 และArray.includes()) - ขอบคุณ @Neil

— ขนปุย

1

CJam , 23 ไบต์

ใช้ความคิดของ Jonathan Allan ในการทำงานกับสันดอน

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.

— Martin Ender
แหล่งที่มา

1

Pyth, 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

— ยูเรียล
แหล่งที่มา

1

JavaScript, 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

รหัสกอล์ฟยาก :)

— StephenRios
แหล่งที่มา

คุณสามารถให้การเป็นตัวแทนไบนารีของรหัสของคุณและเอกสารการลงโทษ?

— Pavel

นี่คือโทษของ 890 สำหรับคะแนนรวม 1,063

— Pavel

เพิ่มผลรวมในโพสต์ดั้งเดิม

— StephenRios

1

การใช้1-1แทน0สถานที่ไม่กี่แห่งอาจช่วยให้คุณประหยัดได้

— Poke

1

Pyth, 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

— notjagan
แหล่งที่มา

1

Retina, 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

บทลงโทษถูกนับด้วยโปรแกรม Pythonนี้

— mbomb007
แหล่งที่มา

โปรดระบุเลขฐานสิบหกและการแทนเลขฐานสองเนื่องจากมีสิ่งที่ไม่สามารถพิมพ์ได้

— Pavel

ฉันได้บอกไปแล้วว่า unprintables อยู่ที่ใดพร้อมกับการจัดให้มีโปรแกรมที่สามารถพิมพ์สตริงไบนารีได้

— mbomb007

เอาล่ะ ..

— พาเวล

1

Python 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

— เดนนิส
แหล่งที่มา

ฉันได้พบว่า0มันไม่ดีที่จะรวม จะดีกว่าที่จะใช้1-1

— Poke

@ โผล่ฉันเพิ่งตระหนักถึงความผิดพลาดของฉัน ผลลัพธ์ไม่ได้ใช้ดังนั้นฉันไม่แน่ใจว่าทำไมฉันถึงเลือก0ตั้งแต่แรก

— Dennis

1

JavaScript (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กว่าครึ่งหนึ่งของโทษที่จะลงไปในศูนย์ทับซ้อนระหว่างไบต์แทนที่จะวิ่งในตัวอักษรต่อไปนี้:

เนื่องจาก/s ( 00101111) จ่ายค่าปรับฉันพยายาม a) เปลี่ยนจากtestเป็นmatchb) เปลี่ยนจากreplaceเป็นmapแต่คะแนนจบลงด้วยเสมอ อย่างไรก็ตามฉันก็พบว่า[\S\s][^]การปรับปรุงมากกว่า แก้ไข: บันทึกโดยรวม 9 ไบต์ขอบคุณ @Shaggy

— นีล
แหล่งที่มา

ฉันคิดว่า|ในคลาสตัวละครไม่ควรจะมี

— ETHproductions

@ETHproductions ฉันเข้าใจถูกต้องในคำอธิบายของฉัน ...

— Neil

คุณสามารถโกน 10 ปิดโทษของคุณโดยการแทนที่!ด้วย1-รวมเป็น 468 และคุณจะทำให้ประหยัดเพิ่มเติม 5 ไบต์โดยการแทนที่[\S\s]ด้วย.รวมเป็น 463.

— ปุย

@Shaggy ขอบคุณแม้ว่าฉันไม่แน่ใจว่าขึ้นบรรทัดใหม่นับเป็นพิมพ์ได้หรือไม่ดังนั้นฉันจะเล่นให้ปลอดภัยตอนนี้

— Neil

js สนับสนุนการตั้งค่าสถานะหลายบรรทัดหรือไม่? ถ้าเป็นเช่นนั้นคุณสามารถยอมรับข้อเสนอแนะของ Shaggy และเพิ่มการตั้งค่าสถานะเพื่อยังคงบันทึกไบต์

— Pavel

1

Pyth , 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 (เป็นรายการย่อย)
การใช้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

— แม่ชีที่ไม่มั่นคง
แหล่งที่มา

ตัดการเชื่อมต่อ 4 บิต

กรณีทดสอบ

กฎระเบียบ

ลีดเดอร์บอร์ด

เยลลี่ , 18 ไบต์ + 0 บทลงโทษ = 18

อย่างไร?

Java 7, 812 726 673 644 634 616 599 588 145 ไบต์ + 10 * 44 = 585

เลขฐานสอง

โซลูชันการเลื่อนบิตแบบเก่า 141 ไบต์ + 10 * 101 = 1,151

เลขฐานสอง

APL (Dyalog Classic) , 26 + 1 × 10 = 36 ไบต์

หมายเหตุ

ส่ง

แหล่งไบนารี

คำอธิบาย

เดินผ่าน

เยลลี่ 28 + 140 demerits = 168

คำอธิบาย

รหัสหน้า

05AB1E , 22 + 3 * 10 = 52

Perl , 33 + 160 = 193

PHP, 98 + 270 = 368 ไบต์

PHP, 86 ไบต์ + 370 = 456

MATL, 16 ไบต์ + 60 = 76 ไบต์

JavaScript (ES8), 91 ไบต์ + 430 บทลงโทษ = 521 รวม

ลองมัน

CJam , 23 ไบต์

Pyth, 19 + 12 * 10 = 139

เลขฐานสอง

คำอธิบาย

JavaScript, 173 + 89 * 10 = 1063

รหัส:

เลขฐานสอง:

คำอธิบาย:

ซอ:

สถิติ:

Pyth, 21 + 2 * 10 = 41

Retina, 101 + 1390 = 1491

Python 2 , 74 (ความยาว) + 130 (ลูกโทษ) = 204

การถ่ายโอนข้อมูลแบบไบนารี

JavaScript (ES6), 87 88 + 390 380 = 477 468 ไบต์

Pyth , 16 + 1 x 10 = 26 ไบต์

เลขฐานสอง

เล่นกล

ปรับปรุง

รุ่น