Nhiệm vụ của bạn: đưa ra một chuỗi đầu vào, xác định xem biểu diễn nhị phân của chuỗi đó không có 4 1s hay 0s liên tiếp ở bất cứ đâu. Hơn nữa, bản thân mã của bạn không được chứa bất kỳ lần chạy bốn liên tiếp nào như vậy.

Các trường hợp thử nghiệm

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

Quy tắc

• Đầu vào sẽ luôn nằm trong phạm vi của ASCII có thể in, bao gồm các ký tự khoảng trắng.
  • Mã của bạn có thể sử dụng bất kỳ mã hóa nào, vì nó chỉ quan trọng ở cấp độ bit.
• Vì điều kiện này ngăn việc sử dụng khoảng trắng và nhiều ký tự khác, nên mã của bạn thực sự có thể chứa các lần chạy bốn liên tiếp như vậy, với mức phạt 10 byte cho mỗi lần chạy.
  • Một lần chạy 5 1giây hoặc 0s được tính là hai lần chạy, 6 lần liên tiếp được tính là ba lần chạy, v.v.
• Đầu vào sẽ là một chuỗi hoặc mảng char, không phải bất kỳ hình thức nào khác.
• Bạn có thể viết một chương trình hoặc chức năng hoàn chỉnh.
• Bạn phải cung cấp biểu diễn nhị phân của mã trong câu trả lời của bạn.

Chúc may mắn, chiến thắng điểm thấp nhất!

Kịch bản này có thể giúp bạn vượt qua thử thách, đưa mã của bạn vào đầu vào và nó sẽ cung cấp cho bạn biểu diễn nhị phân của mã, độ dài, hình phạt của bạn và tổng số điểm, nếu bạn đang sử dụng UTF-8.

Bảng xếp hạng

Dưới đây là Stack Snippet để tạo cả bảng xếp hạng thông thường và tổng quan về người chiến thắng theo ngôn ngữ.

/* 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>

Jelly , 18 byte + 0 hình phạt = 18

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

Trả về 1nếu không có chuỗi bit bằng nhau có độ dài 4 trở lên trong biểu diễn từ 8 bit của đầu vào chuỗi ASCII, và 0ngược lại.

Hãy thử trực tuyến! (bộ thử nghiệm với một số trường hợp thêm vào)

Sử dụng bảng mã của Jelly, không có chuỗi 4 hoặc dài hơn các bit bằng nhau:

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

Với độ dài chạy bằng nhau của:

221323221211111312322133122121221111213121123132213111122211311332313211313211111112

Làm sao?

Thủ thuật để tránh các hành vi là:

• để tránh đơn vị "chuyển đổi từ ký tự sang thứ tự" Obằng cách chuyển đổi số 79thành ký tự bằng cách sử dụng Ọ"đánh giá mã Jelly với đầu vào" , v.

• để tránh chuyển đổi trực tiếp thành nhị phân bằng cách sử dụng B( 0x42, 1000010) bằng cách thay thế hai byte đơn giản b2bằng cách sử dụng chuyển đổi cơ sở dyadic chung.

• để tránh một vài lựa chọn bình thường để đếm các bit bằng nhau - lựa chọn đầu tiên sẽ là "tất cả các lát chồng chéo có độ dài nhất định", ṡ( 0xF5hoặc 11110101). Lựa chọn thứ hai có thể là sử dụng "tất cả danh sách phụ", Ẇ( 0xCFhoặc 11001111).
  Một cách giải quyết khác mà tôi đã sử dụng trước phần hiện tại là lấy số gia (giữa các phần tử liên tiếp) với I(đặt số không và số trên một số bằng nhau) và tìm kiếm bất kỳ sự xuất hiện nào của ba số không liên tiếp. Để làm điều đó tôi chuyển đổi tất cả các số không cho những người thân bằng cách sử dụng các chức năng nhị thức với 2cnghĩa 2Cx - làm cho -1s trở 0s các 1s trở 2s, và 0s trở thành1S; bằng cách đó, mã có thể tìm kiếm sự xuất hiện đầu tiên của danh sách con [1,1,1]với w111.
  Tuy nhiên, một cách ngắn hơn đã trở nên rõ ràng - để bắt chước hành động của "tất cả các lát chồng chéo có độ dài nhất định" ṡ, người ta có thể sử dụng giảm chồng chéo 4 chiều với một số đê , <dyad>4\. Nếu điều này được thực hiện với phép cộng, +4\nó sẽ tính 1s, do đó, bất kỳ 0hoặc 4hiện diện là chỉ báo để trả về giá trị trung thực. Vấn đề ở đây là các bước rõ ràng tiếp theo sẽ là lấy modulo 4 điều đó để đưa 0và 4mục trên cơ sở bình đẳng trong khi rời khỏi giá trị có thể khác ( 1, 2và 3) không thay đổi, nhưng +\%4có\%bên trong, trong đó có chút giá trị 010.111 0000 100100. Để tránh hình phạt mà các con số đều chuyển sang cơ sở 4 với b4(lập bản đồ 0đến [0], 1đến [1], 2đến [2], 3đến [3], và 4đến [1,0]) và toàn bộ danh sách được làm phẳng với F. Bây giờ thử nghiệm cuối cùng chỉ đơn giản là kiểm tra xem có bất kỳ 0s nào trong danh sách hay không, có thể đạt được trực tiếp với đơn nguyên Ạ.

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?

Lưu ý: Lý do số 2 được nối với danh sách thứ tự là để xử lý các trường hợp cạnh trong đó lần chạy duy nhất của 4 trong chuỗi đầu vào nằm trong các số 0 đứng đầu của ký tự đầu tiên - các ký tự này là: tab; nguồn cấp dữ liệu; và vận chuyển trở lại. Không có điều này, chuyển đổi cơ sở 256 có hiệu quả loại bỏ các số 0 đứng đầu khỏi chuỗi nhị phân (được nối hoàn toàn); với 2 số 0 đứng đầu, các số 0 đứng đầu sẽ ở đó và thêm một số 0 trước chúng. Vì ASCII không thể in được có chính xác ba số 0 đứng đầu, nên không cần loại bỏ các bit thừa này trước phần còn lại của kiểm tra.

Java 7, 812 726 673 644 634 616 599 588 145 byte + 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.*");}

Tôi đang sử dụng các dòng mới thay vì khoảng trắng để cố gắng giảm thiểu hình phạt ...

Hãy thử trực tuyến!

Nhị phân

01100010011011110110111101101100011001010110000101101110000010100110001000101000011000110110100001100001011100100101101101011101011000100010100101111011010100110111010001110010011010010110111001100111000010100110011100111101001000100010001000111011011001100110111101110010001010000110001101101000011000010111001000001010011000110011101001100010001010010110011100101011001111010110011100101110011001100110111101110010011011010110000101110100001010000010001000100101001000100010101100101000001100010010110100110001001010010010101100100010001110000110010000100010001011000110111001100101011101110000101001001001011011100111010001100101011001110110010101110010001010000100100101101110011101000110010101100111011001010111001000101110011101000110111101010011011101000111001001101001011011100110011100101000011000110010110000110010001010010010100100101001001110110111001001100101011101000111010101110010011011100010000101100111001011100110110101100001011101000110001101101000011001010111001100101000001000100010111000101010001010000010111000101001010111000101110000110001010111000101110000110001010111000101110000110001001011100010101000100010001010010011101101111101

Giải pháp bẻ khóa cũ 141 byte + 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;}

Hãy thử trực tuyến!

Nhị phân

011000100110111101101111011011000110010101100001011011100000101001100010001010000110001101101000011000010111001001011011010111010110001000101001011110110000101001101001011011100111010000001010011011110011110100110000001011000111000000111101001100000010110001101001001110110000101001100110011011110111001000101000011000110110100001100001011100100000101001100011001110100110001000101001011110110110011001101111011100100010100001101001001111010011000000111011011010010011110000111000001110110010100101111011011010010110011000101000001010000110001100100110001010000011000100111100001111000110100100101011001010110010100100101001001111000011000100101001011110110110111100111101001100000011101101110000001010110010101100111011011111010110010101101100011100110110010101111011011100000011110100110000001110110110111100101011001010110011101101111101011010010110011000101000001100110011110001101111011111000011001100111100011100000010100101110010011001010111010001110101011100100110111000001010001101100011110000110101001110110111110101111101011100100110010101110100011101010111001001101110000010100011010100111100001101100011101101111101

APL (Dyalog Classic) , 26 + 1 × 10 = 36 byte

Ghi chú

Chứa 1 4 lần chạy. Yêu cầu ⎕IO←0mặc định trên nhiều hệ thống. Lưu ý rằng điều này phải được chạy trên trình thông dịch Cổ điển để các chuỗi là một byte cho mỗi ký tự.

Nộp hồ sơ

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

Hãy thử trực tuyến!

Nguồn nhị phân

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

Giải trình

⍞ Nhắc về đầu vào chuỗi

11 ⎕DR chuyển đổi thành 1 -bit Boolean ( 1 ) D ata R epresentation

⊂ kèm theo để chúng ta có thể áp dụng nhiều thứ cho nó

(Các ) ⍷¨ chỉ số nhị phân của Moz trong đó mỗi chuỗi sau đây bắt đầu

 × ký (không có op trên dữ liệu nhị phân, nhưng được bao gồm dưới dạng spacer để phân chia chạy)

 4 \¨ mở rộng (sao chép) mỗi chiều dài bốn

 ⍳ các số nguyên lên đến

 ≢ kiểm đếm của

 ⍬⍬  danh sách bao gồm hai danh sách số trống

∊ tranh thủ (làm phẳng)

⌈\ tích lũy tối đa

⌽ đảo ngược

⊃ chọn cái đầu tiên

1 ≠ là một khác nhau từ? (tức là KHÔNG)

Đi qua

Chúng tôi sẽ nhập "48" cho phiên bản chưa được chạy ~ ∨/ ∊ (0 0 0 0)(1 1 1 1) ⍷¨ ⊂ 11 ⎕DR ⍞:

11 ⎕DR ⍞ chuyển đổi "48" thành 0 0 1 1 0 1 0 0 0 0 1 1 1 0 0 0 (tức là ngày 52 tháng 12 56, Hex 34 38)

(0 0 0 0)(1 1 1 1) ⍷¨ ⊂tìm thấy sự khởi đầu của 0 lần chạy và 1 lần chạy; (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)

∨/ ∊xem nếu có bất kỳ sự thật (tức là bất kỳ chạy); 1

~phủ nhận rằng; 0

Thạch 28 + 140 giảm = 168

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

Giải trình

OB

Chuyển đổi đối số thành một danh sách mã hóa nhị phân của họ, ví dụ

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

Phần tiếp theo

UÇ€U

sửa lỗi thực tế là danh sách trên có thể thiếu các ký tự vì Bkhông bao gồm các số 0 đứng đầu. Ç€gọi liên kết được xác định trước đó trên mỗi phần tử khôi phục lại

L8_0xṭ

Liên kết này tương đương với

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

Ví dụ

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

Chúng tôi nâng cấp danh sách trước và sau thao tác này (hai Ucuộc gọi trong danh sách đó) để làm cho đó là một khoản trả trước thay vì nối thêm. Phần tiếp theo

FŒr

Làm phẳng danh sách ( F), đưa ra tổng chuỗi nhị phân của mã hóa ASCII và độ dài chạy mã hóa đầu ra ( Œr). Ví dụ

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

và

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]]

Cuối cùng, chúng tôi kiểm tra xem mỗi phần tử có <4 hay không (rất may điều này luôn đúng với 0,1) với

<4F

Ví dụ

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]

Cuối cùng

Ạ

Trả về 0 nếu bất kỳ trong số đó là giả (trong trường hợp này là 0).

Trang mã

Trong trang mã của Jelly, mã này là 20 byte nhưng có 27 lỗi vi phạm quy tắc. Trong UTF-8, nó là 28 byte nhưng chỉ có 14 lần vi phạm.

05AB1E , 22 + 3 * 10 = 52

Lưu 2 hình phạt chạy vay các đồng bằng lừa từ Jonathan Allan của câu trả lời Jelly

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

Hãy thử trực tuyến!

Giải trình

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

Đại diện nhị phân của mã

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

3 lần chạy hình phạt đến từ vy¦}đó được sử dụng để cắt byte đầu tiên trong mỗi chuỗi nhị phân, nhưng nó vẫn rẻ hơn so với 4 lần chạy mà chúng tôi nhận được từ ngắn hơn €¦.

Perl , 33 + 160 = 193

32 byte mã + 1 byte cho -ncờ.

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

(đầu vào cần được cung cấp mà không có dòng mới cuối cùng. Liên kết Dùng thử trực tuyến có -lgắn cờ để xóa dòng mới, nhưng đối với một đầu vào, không cần thiết).

Hãy thử trực tuyến!

bãi rác 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+

Một vài lưu ý:

• (.)\1\1\1tiết kiệm một vài hình phạt trên (.)\1{3}, 1111|0{4}hoặc bất kỳ regex nào khác tôi có thể nghĩ đến (sử dụng 0hoặc {}đi kèm với chi phí lớn).
• printtiết kiệm ~ 8 điểm so với sử dụng -pvà $_=vì pchứa một hoạt động của 4 0trong khi nkhông.
• +như một dấu phân cách cho biểu thức chính quy tiết kiệm một bước chạy trong 1đó /.
• thực hiện hai bước thay vì một với !~lưu hai lần chạy ( ~là 01111110ở dạng nhị phân).
• unpack"B*"là khá đắt (4 lần chạy), nhưng tôi không thể tìm thấy rẻ hơn (các giải pháp dựa trên ordsẽ còn đắt hơn).

PHP, 98 + 270 = 368 byte

Tôi muốn thực hiện một cách tiếp cận khác với những gì Titus đề xuất , và kết thúc với một chương trình dài hơn một chút, nhưng ít bị phạt hơn.

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

Đầu ra 1cho sự thật, không có gì cho falsey.

Hãy thử nó ở đây!

Mã hóa nhị phân:

0010010001110110001111010111010101101110011100000110000101100011011010110010100
0001001110100100000101010001001110010110000100100011000010111001001100111011101
1001011011001100010101110100101001001110110010010001100101001111010110001001100
0010111001101100101010111110110001101101111011011100111011001100101011100100111
0100001010000010010001110110010110110011000101011101001011000011000100110110001
0110000110010001010010011101101100101011000110110100001101111001000010111001101
1101000111001001101001011100110111010001110010001010000010010001100101001011000
0100111001100000011000000110000001100000010011100101001001001100010011000100001
0111001101110100011100100110100101110011011101000111001000101000001001000110010
1001011000010011100110001001100010011000100110001001001110010100100111011

(22 lần xuất hiện 0000và 5 lần xuất hiện 1111, do đó 270 byte hình phạt)

PHP, 86 byte + 370 = 456

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

tạo chuỗi nhị phân và sử dụng biểu thức chính quy để phát hiện các vệt. Đầu ra là 1cho sự thật; trống cho giả.

Chạy với echo '<string>' | php -nR '<code>'.

điều chỉnh

• backreferences lưu 100 hình phạt cho 3 byte. (-97 điểm)

ý tưởng bị bỏ rơi

• join(array_map(str_split())) sẽ tốn 31 byte và 90 hình phạt
• và <?=/ $argv[1]thay vì echo/ $argnchi phí thêm 2 + 40.
• str_pad(decbin())đắt hơn sprintf: 7 byte và 110 hình phạt.
• strtr tiết kiệm 80 hình phạt cho 13 byte bổ sung, nhưng phản hồi lại tốt hơn.
• Nhóm các backreferences #(.)\\1{3}tiết kiệm 3 byte, nhưng thêm 10 hình phạt.
• foreach chi phí 3 + 50.
• Không thể lưu vào tên biến.
• chi phí đệm đầu ra 42 + 120.

MATL, 16 byte + 60 = 76 byte

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

Dùng thử tại MATL Online

JavaScript (ES8), 91 byte + 430 hình phạt = tổng 521

Điều này sẽ đầu ra 1cho truevà 0cho false.

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

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000010110110010111000101110001011100111001101011101001011100110110101100001011100000010100001100011001111010011111001100011001011100110001101101000011000010111001001000011011011110110010001100101010000010111010000101000001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110000011000010110010001010011011101000110000101110010011101000010100000110011001010110011010100101100001100010010110100110001001010010010100100101110011010100110111101101001011011100010100000100010001000100010100100101001

Thử nó

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

CJam , 23 byte

Sử dụng ý tưởng của Jonathan Allan để làm việc với deltas.

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

Hãy thử trực tuyến!

Đại diện nhị phân:

00110001011100010011001000110101
00110110011000100011001001100010
00110010011001010111011100111010
00111010001011010101101101010100
01010100010101000101110100100011
001010010110011100101101

Giải trình:

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.

Bình thường, 19 + 12 * 10 = 139

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

Nhị phân

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

Giải trình

!|}*"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

JavaScript, 173 + 89 * 10 = 1063

JavaScript không tốt trong việc chuyển đổi chuỗi thành nhị phân, nhưng tôi đoán rằng tôi sẽ thử thách này chỉ để giải trí.

Mã số:

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}

Nhị phân:

0110011001110101011011100110001101110100011010010110111101101110001010000110111000101001011110110110001000111101001000100010001000111011011001100110111101110010001010000111011001100001011100100010000001110100001111010011000000111011011101000011110001101110001011100110110001100101011011100110011101110100011010000011101101110100001010110010101100101001011000110011110101011011011011100010111001100011011010000110000101110010010000110110111101100100011001010100000101110100001010000111010000101001001011100111010001101111010100110111010001110010011010010110111001100111001010000011001000101001010111010010110001100011001011100111010101101110011100110110100001101001011001100111010000101000010000010111001001110010011000010111100100101000001110000010110101100011010110110011000001011101001011100110110001100101011011100110011101110100011010000010101100110001001010010010111001101010011011110110100101101110001010000011000000101001001010010010110001100010001010110011110101100011001011100110101001101111011010010110111000101000001000100010001000101001001110110111001001100101011101000111010101110010011011100010000001100010001011100110110101100001011101000110001101101000001010000010111101011011001100010101110101111011001101000010110001111101011111000101101100110000010111010111101100110100001011000111110100101111011001110010100100111111001000010011000100111010001000010011000001111101

Giải trình:

Tạo một chuỗi để làm việc với:

b="";

Lặp lại từng ký tự trong chuỗi:

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

Tạo một mảng và chuyển đổi chuỗi thành nhị phân bằng mã ký tự:

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

Thêm các số 0 đứng đầu vào mảng:

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

Tham gia mảng trở lại thành một chuỗi:

b+=c.join("")

Trả về việc có tìm thấy một chuỗi gồm bốn hoặc nhiều hơn 1 hoặc 0 trong kết quả nhị phân bằng biểu thức chính quy hay không:

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

Vĩ cầm:

https://jsfiddle.net/vrtLh97c/

Số liệu thống kê:

Độ dài: 173 byte Hình phạt: 890 Tổng cộng: 1063

Code Golf thật khó :)

Bình thường, 21 + 2 * 10 = 41

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

Hãy thử trực tuyến!

Đại diện nhị phân:

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

Võng mạc, 101 + 1390 = 1491

Mã chứa các ký tự không thể in được, nhưng chúng sẽ hiển thị trong Chrome nếu bạn chỉnh sửa bài đăng. -là \x01-\x7f.

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

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

Dùng thử trực tuyến

Mã nàyord sử dụng mã này , theo sau là chuyển đổi thành nhị phân và kiểm tra đơn giản cho các chuỗi trùng lặp của bốn.

Ở dạng nhị phân:

11000010101101100000101011000010101100010000101001010011010111110110000000001010001001010010100001010011011000001100001010110001000010100111101100110010011000000000101000100100011000000000101001111101010101000011000000110001011000000000000100101101011111110110000001011111011011110000101000101001010011010111001101100000001011100000101000101110001010110000101000100100001010100000101000101011011000000010100000110001001010110010100100000001000010100010010001111011001100010111110100110000000010100011000000110001000010100011000100001010011011010010101101100000010111100010100000111111001000010010111001111011001110000111110100101001000010100011000000001010001100000111101100111000011111010111110011000010101101100000101000001010010011010010011001100000001010000010111000101001000000010111101100110011011111010000101000110000

Hình phạt được tính với chương trình Python này .

Python 2 , 74 (chiều dài) + 130 (hình phạt) = 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

Đầu ra là thông qua mã thoát; 0 là sự thật, 1 là giả dối. Tạo đầu ra rác thành STDOUT và STDERR.

Hãy thử trực tuyến!

Đổ nhị phân

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

JavaScript (ES6), 87 88 + 390 380 = 477 468 byte

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

Ở dạng nhị phân:

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000011100110010111001110010011001010111000001101100011000010110001101100101001010000010111101011011010111000101001101011100011100110101110100101111011001110010110001100011001111010011111000101000001100100011010100110110001010110110001100101110011000110110100001100001011100100100001101101111011001000110010101000001011101000010100000101001001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110011011011000110100101100011011001010010100000110001001010010010100100101001

Hơn một nửa hình phạt là số không trong các phần chồng chéo giữa các byte, thay vì chạy trong các ký tự sau : =>//pa//=>aCoAo.

Vì /s ( 00101111) trả tiền phạt nên tôi đã thử a) chuyển từ testsang matchb) chuyển từ replacesang mapnhưng điểm luôn kết thúc cao hơn. Tuy nhiên tôi đã thấy rằng đó [\S\s]là một cải tiến hơn [^]. Chỉnh sửa: Đã lưu 9 byte tổng thể nhờ @Shaggy.

Pyth , 16 + 1 x 10 = 26 byte

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

Hãy thử trực tuyến!

Nhị phân

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

Thủ thuật

Các lựa chọn thay thế sau đây được thực hiện để tránh các điểm trừ:

• Sử dụng qZ(bằng 0) thay vì !(phủ định)
• Sử dụng :xy0(tìm kiếm) thay vì }xy(là danh sách phụ)
• Sử dụng Z(biến, mặc định là 0) thay vì 0(không chính nó)

Cải tiến

Tôi không tìm ra cách nào để lách luật. Chúng tôi có các lệnh liên quan đến nhị phân:

• .Bnhị phân ( 00101110 01[0000]10)
• Cmã số ( 01[0000]11)
• .Oquãng tám ( 00101110 0100[1111])
• .Hthập lục phân ( 00101110 01001[000)

Lưu ý rằng điều đó .Hcũng sẽ cho chúng ta một hình phạt, bởi vì mọi ký tự có thể in đều có biểu diễn nhị phân bắt đầu bằng 0. Do đó, tôi đã sử dụng một cách trực tiếp nhất, đó là .B, trực tiếp chuyển đổi nó thành nhị phân.

Tôi có thể kết thúc .Hđể tránh bị phạt, nhưng nó tiêu tốn của tôi 27 byte ...

Thế hệ

Tôi đã tìm thấy tất cả các ký tự được phép, đó là những ký tự không chứa 0000hoặc 1111và không kết thúc bằng 000(vì ký tự tiếp theo phải bắt đầu bằng 0):

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

Dưới đây là các nhân vật kết thúc với 1000. Chúng chỉ có thể được sử dụng ở cuối:

• (8HXhx