您的任务：给定一个输入字符串，确定该字符串的二进制表示形式在任何位置连续没有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计为三运行，依此类推。
• 输入将是字符串或char数组，而不是任何其他形式。
• 您可以编写完整的程序或功能。
• 您必须在答案中提供代码的二进制表示形式。

祝你好运，最低分获胜！

如果您使用的是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>

果冻，18 字节 + 0罚分= 18

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

1如果在ASCII字符串输入的8位字表示形式中没有长度等于或大于4的相等位串，则返回；0否则返回。

在线尝试！（添加了一些额外案例的测试套件）

使用Jelly的代码页，不存在长度为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而是使用通用二进位基本转换方法。

• 为了避免对计数相等位的游程进行一些正常选择-第一个选择是“给定长度的所有重叠切片” ṡ（0xF5或11110101）。第二种选择可能是利用“所有子列表” Ẇ（0xCF或11001111）。
  我在当前值之前使用的一种变通办法是：在（连续的元素之间）使用I（在相同的立足点上放置零和1 ）的增量，并寻找连续出现三个零的任何情况。要做到这一点我使用二项式功能的转换所有零到那些2c即2CX -使得-1S ^成为0S中的S; 这样的代码可以寻找子列表中第一次出现用。1小号成为2S和0小号成为1[1,1,1]w111
  但是，出现了一种更短的方法-模仿“给定长度的所有重叠切片”的作用，ṡ可以使用带有一些对分的4方向重叠约简<dyad>4\。如果通过加法执行此操作+4\，它将对1s 进行计数，因此任何一个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列表中是否存在任何，可以直接通过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?

注意：a 2与序数列表连接的原因是要处理以下情况：输入字符串中的4的唯一游程在第一个字符的前导零中-这些字符是：tab; 换行 和回车。没有这个，基数256转换将有效地从（完全串联的）二进制字符串中去除前导零。与领先2前导零将在那里和他们之前的额外1和0。由于没有可打印的ASCII码正好具有三个前导零，因此无需在其余检查之前就丢弃这些多余的位。

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

APL（Dyalog Classic），26 + 1×10 = 36字节

笔记

包含1的4次运行。要求⎕IO←0在许多系统上是默认设置。请注意，这必须在Classic解释器上运行，以便字符串是每个字符一个字节。

投稿

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

在线尝试！

二进制源

_{^{00110001101011001001110010110010100101110101110010111001001010001101011100110100010111001010100010}} 1111 _{^{001011101110101011101010110010100110110101001010001001101100110001001100011000110001000100010101001010001101}}

说明

⍞ 提示输入字符串

11 ⎕DR 转换为1比特的布尔（1）d ATA ř epresentation

⊂ 附上，以便我们可以对其应用多个内容

(… ) ⍷¨ 以下每个序列开始的二进制指示符…

 × 符号（对二进制数据无操作，但作为分隔符包含在运行中）

 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 0 1 1 1 0 0 0（即Dec 52 56，Hex 34 38）

(0 0 0 0)(1 1 1 1) ⍷¨ ⊂查找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 0 0 0 0 0）

∨/ ∊看是否有真相（即任何奔跑）；1个

~否定 0

果冻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

展宽列表（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）。

代码页

在Jelly的代码页中，该代码为20个字节，但是有27条运行值得违反规则。在UTF-8中，它是28个字节，但是只有14次违反行为。

05AB1E，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

3罚分运行来自于vy¦}其中，用于截取每个二进制字符串中的第一个字节，但它仍然比我们从较短的4 罚分中获得的便宜€¦。

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}或我可能想到的任何其他正则表达式的罚款（使用0或{}费用高昂）。
• print与使用相比节省了〜8点-p，$_=因为p包含4的运行0而n没有。
• +作为正则表达式的定界符保存1in中的运行/。
• 做两个步骤，而不是一个具有!~节约两分（~是01111110二进制）。
• unpack"B*"是相当昂贵的（4次运行），但是我找不到更便宜的解决方案（基于该解决方案的价格ord甚至会更高）。

PHP，98 + 270 = 368字节

我想采用与Titus提议的方法不同的方法，并以稍长一些但处罚较少的程序结束。

$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个字节的罚款）

PHP，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>'。

调整

• 向后引用可节省100个3字节的罚款。（-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。

MATL，16字节+ 60 = 76字节

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

在MATL Online上尝试

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

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.

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

JavaScript，173 + 89 * 10 = 1063

JavaScript并不擅长将字符串转换为二进制，但是我想我会为这个挑战做个简单的尝试。

码：

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

Code Golf很难:)

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

视网膜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程序的罚款计入。

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

JavaScript（ES6），87 88 + 390 = 477468字节

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]是对的改进[^]。编辑：感谢@Shaggy，总共节省了9个字节。

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