あなたのタスク：入力文字列が与えられたら、その文字列のバイナリ表現に4 1sまたは0sが連続していないかどうかを判断します。さらに、コード自体には、このような4つの実行が連続して含まれてはなりません。

テストケース

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バイトのペナルティで、このような4つの実行が連続して含まれます。
  • 5 1sまたは0sの実行は2回の実行としてカウントされ、6行の実行は3回の実行としてカウントされます。
• 入力は文字列または文字配列であり、他の形式ではありません。
• 完全なプログラムまたは関数を作成できます。
• 回答にコードのバイナリ表現を入力する必要があります。

幸運を祈ります、最低スコアが勝ちます！

このスクリプトは、チャレンジに役立ち、コードを入力に入れると、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Ạ

ASCII文字列入力の8ビットワード表現に1長さ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ます。

• 一般的なダイアディックベース変換を使用する単純な2バイトの代替手段によるB（0x42、1000010）を使用したバイナリへの直接変換を回避しb2ます。

• 等しいビットの実行をカウントするためのいくつかの通常の選択を避けるために-最初の選択は「指定された長さのすべての重複スライス」ṡ（0xF5または11110101）です。2番目の選択肢は、「すべてのサブリスト」を使用することですẆ（0xCFまたは11001111）。
  現在の解決策の前に使用した回避策は、（連続した要素間で）増分（Iゼロと1を等しい足場に置く）を取得し、3つのゼロの発生を連続して検索することでした。それを行うには、2Cxの二項関数を使用して、すべてのゼロを1に変換します。2cつまり、sがsになり、sがsになり、sがsになります。-101201s; その方法は、コードは、サブリストの最初の出現を探すことができます[1,1,1]とw111。
  しかし、より短い方法が明らかになりました-「与えられた長さのすべてのオーバーラップスライス」の動作を模倣するために、いくつかのダイアドで4ワイズオーバーラップリデュースをṡ使用できます。これを加算で実行すると、sがカウントされるため、any またはpresentは、真の値を返すインジケーターです。ここでの問題は、次の明白なステップはモジュロ取ることであろうということである4入れているのをし、他の可能な値を残したまま（対等な立場でのエントリを、と）変わらないが、持っています<dyad>4\+4\10404123+\%4\%ビット値010111有する内側、0000ペナルティ数字は、すべての塩基に変換されることを回避するために、100100.を4とb4（マッピング0に[0]、1へ[1]、2へ[2]、3へ[3]、及び4へ[1,0]）とリスト全体を用いて平坦化されますF。最後のテストは0、リストにs があるかどうかを単純にチェックすることẠです。これは、モナドで直接達成できます。

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には先頭のゼロがあり、その前に1と0が追加されます。印刷可能なASCIIには先行ゼロがちょうど3つないため、残りのチェックの前にこれらの余分なビットを破棄する必要はありません。

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ランが1つ含まれます。⎕IO←0多くのシステムでデフォルトである必要があります。文字列が文字ごとに1バイトになるように、これはクラシックインタープリターで実行する必要があることに注意してください。

提出

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

オンラインでお試しください！

バイナリソース

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

説明

⍞ 文字列入力のプロンプト

11 ⎕DR 変換する1ビットブール（1）D ATA R epresentation

⊂ 複数のことを適用できるように囲みます

(… ) ⍷¨ 次の各シーケンスが始まるバイナリインジケータ…

 × 符号（バイナリデータでは何もしませんが、分割実行のスペーサーとして含まれます）

 4 \¨ それぞれを長さ4に展開（コピー）します

 ⍳ までの整数

 ≢ の集計

 ⍬⍬  2つの空の数値リストで構成されるリスト

∊ 参加（フラット化）

⌈\ 累積最大

⌽ 逆

⊃ 最初を選ぶ

1 ≠ とは違うの？（つまりNOT）

ウォークスルー

実行されていない、実行されていないバージョンに「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に変換します（つまり、12月52 56、16進数34 38）

(0 0 0 0)(1 1 1 1) ⍷¨ ⊂0ランと1ランの始まりを見つけます。（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

ゼリー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リスト内の2つの呼び出し）の前後にリストを更新して、それを追加ではなく追加にします。次の作品

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バイトのコード+ -nフラグ用の1バイト。

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

（入力は最後の改行なしで提供する必要があります。Tryit onlineリンクには-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して$_=いるのでp4の実行が含まれてい0ながら、nしません。
• +正規表現の区切り文字として、の実行が保存さ1れ/ます。
• 2段階の代わりと1やって!~二つの実験を節約することは（~ある01111110バイナリで）。
• unpack"B*"かなり高価です（4回実行）が、私はもっと安く見つけることができなかった（ベースのソリューションはordさらに高価になるだろう）

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バイトのペナルティ）

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>'ます。

微調整

• 後方参照により、3バイトで100ペナルティが節約されます。（-97スコア）

放棄されたアイデア

• join(array_map(str_split())) 31バイトと90ペナルティがかかります
• そして、<?=/ $argv[1]の代わりにecho/ $argnコスト別の2 + 40。
• str_pad(decbin())よりコストが高いsprintf：7バイトと110ペナルティ。
• strtr 13バイト余分に80のペナルティを節約できますが、後方参照の方が優れています。
• 後方参照をグループ化すると、#(.)\\1{3}3バイト節約されますが、10ペナルティが追加されます。
• foreach 費用は3 + 50です。
• 変数名の保存はできません。
• 出力バッファリングのコストは42 + 120です。

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バイト

ジョナサンアランのアイデアを使用して、デルタを処理します。

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

正規表現を使用して、バイナリ結果で4つ以上の1または0の文字列が見つかったかどうかを返します。

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

フィドル：

https://jsfiddle.net/vrtLh97c/

統計：

長さ：173バイトペナルティ：890合計：1063

コードゴルフは難しいです:)

パイス、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使用し、その後にバイナリに変換し、重複する4つのシーケンスを簡単にチェックします。

バイナリで：

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 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）私が試したペナルティ）からの切り替え支払うtestへmatchの切り替えB）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]）
• .H16進数（00101110 01001[000）

注.Hすべての印字可能な文字はそのバイナリ表現で始まるを持っているので、また、私たちに罰を与えるだろう0。したがって、最も直接的なもの、つまり.B、直接バイナリに変換するものを使用しました。

.Hペナルティを回避するために終了できますが、27バイトかかります...

世代

許可されているすべての文字を見つけました。これらの文字は、0000またはを含ま1111ず、末尾が末尾ではありません000（次の文字はで始まる必要があるため0）。

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

で終わる文字は次のとおり1000です。それらは最後にのみ使用できます：

• (8HXhx