Tugas Anda: diberi string input, tentukan apakah representasi biner dari string itu tidak memiliki 4 1s atau 0s berturut-turut, di mana saja. Selain itu, kode Anda sendiri tidak boleh berisi empat berjalan berturut-turut.

Uji Kasus

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

Aturan

• Input akan selalu berada dalam kisaran ASCII yang dapat dicetak, termasuk karakter spasi putih.
  • Kode Anda dapat menggunakan penyandian apa pun, karena itu hanya penting pada tingkat bit.
• Karena kondisi ini mencegah penggunaan ruang putih dan banyak karakter lainnya, kode Anda sebenarnya dapat berisi proses empat kali berturut-turut, dengan penalti 10 byte untuk setiap proses.
  • Run 5 1s atau 0s dihitung sebagai dua run, 6 berturut-turut dihitung sebagai tiga run, dll
• Input akan berupa string atau array char, bukan bentuk lainnya.
• Anda dapat menulis program atau fungsi yang lengkap.
• Anda harus memberikan representasi biner dari kode Anda dalam jawaban Anda.

Semoga berhasil, skor terendah menang!

Skrip ini dapat membantu Anda dengan tantangan Anda, memasukkan kode Anda di input dan itu akan memberi Anda representasi biner kode Anda, panjangnya, penalti Anda, dan skor total, jika Anda menggunakan UTF-8.

Papan peringkat

Berikut ini adalah Stack Snippet untuk menghasilkan leaderboard biasa dan gambaran umum pemenang berdasarkan bahasa.

/* 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 penalti = 18

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

Mengembalikan 1jika tidak ada string bit yang sama dengan panjang 4 atau lebih dalam representasi kata 8-bit dari input string ASCII, dan 0sebaliknya.

Cobalah online! (test suite dengan beberapa case tambahan ditambahkan)

Menggunakan codepage Jelly tidak ada substring dengan panjang yang sama dengan 4 atau lebih panjang:

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

Dengan panjang menjalankan bit yang sama:

221323221211111312322133122121221111213121123132213111122211311332313211313211111112

Bagaimana?

Trik untuk menghindari kekurangan adalah:

• untuk menghindari monad "konversi dari karakter ke ordinal" Odengan mengonversi angka 79menjadi karakter menggunakan Ọdiikuti oleh "evaluasi kode Jelly dengan input" v,.

• untuk menghindari konversi langsung ke biner menggunakan B( 0x42, 1000010) dengan alternatif dua byte sederhana b2menggunakan konversi basis dyadic generik.

• untuk menghindari beberapa pilihan normal untuk menghitung run bit yang sama - pilihan pertama adalah "semua irisan yang tumpang tindih dengan panjang yang diberikan", ṡ( 0xF5atau 11110101). Pilihan kedua mungkin menggunakan "semua sublists", Ẇ( 0xCFatau 11001111).
  Solusi yang saya gunakan sebelum yang saat ini adalah untuk mengambil kenaikan (antara elemen berturut-turut) dengan I(menempatkan nol dan yang pada pijakan yang sama), dan untuk mencari kemunculan tiga nol berturut-turut. Untuk melakukan itu, saya mengubah semua nol menjadi nol dengan menggunakan fungsi binomial dengan 2cyaitu 2Cx - membuat -1s menjadi 0s 1s menjadi 2s, dan 0s menjadi1s; bahwa cara kode dapat mencari kejadian pertama dari sublist [1,1,1]dengan w111.
  Namun cara yang lebih singkat menjadi jelas - untuk meniru aksi "semua irisan yang tumpang tindih dengan panjang yang diberikan" ṡ, seseorang dapat menggunakan pengurangan 4 arah yang tumpang tindih dengan beberapa angka dua <dyad>4\,. Jika ini dilakukan dengan tambahan,, +4\ia menghitung 1s, maka setiap 0atau 4yang hadir adalah indikator untuk mengembalikan nilai yang sebenarnya. Masalah di sini adalah bahwa langkah jelas berikutnya akan mengambil Modulo 4 itu untuk menempatkan 0dan 4entri pada pijakan yang sama sementara meninggalkan nilai-nilai lain yang mungkin ( 1, 2, dan 3) tidak berubah, tetapi +\%4memiliki\%di dalam, yang memiliki nilai bit 010111 0000 100100. Untuk menghindari penalti itu semua angka dikonversi ke basis 4 dengan b4(pemetaan 0ke [0], 1ke [1], 2ke [2], 3ke [3], dan 4ke [1,0]) dan seluruh daftar diratakan dengan F. Sekarang tes terakhir adalah hanya untuk memeriksa apakah ada 0dalam daftar, dapat dicapai langsung dengan 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?

Catatan: Alasan a 2 digabungkan dengan daftar ordinal adalah untuk berurusan dengan kasus tepi di mana satu-satunya run dari 4 dalam string input berada di nol di depan karakter pertama - karakter ini adalah: tab; umpan baris; dan carriage-return. Tanpa ini, basis 256 konversi secara efektif menghapus nol terkemuka dari string biner (sepenuhnya digabung); dengan angka 2 di depan, angka nol di depannya akan ada di sana dan satu angka nol di depannya. Karena tidak ada ASCII yang dapat dicetak yang memiliki tepat tiga angka nol di depan, maka tidak perlu membuang bit tambahan ini sebelum sisa pemeriksaan.

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.*");}

Saya menggunakan baris baru, bukan spasi untuk mencoba meminimalkan penalti ...

Cobalah online!

Biner

01100010011011110110111101101100011001010110000101101110000010100110001000101000011000110110100001100001011100100101101101011101011000100010100101111011010100110111010001110010011010010110111001100111000010100110011100111101001000100010001000111011011001100110111101110010001010000110001101101000011000010111001000001010011000110011101001100010001010010110011100101011001111010110011100101110011001100110111101110010011011010110000101110100001010000010001000100101001000100010101100101000001100010010110100110001001010010010101100100010001110000110010000100010001011000110111001100101011101110000101001001001011011100111010001100101011001110110010101110010001010000100100101101110011101000110010101100111011001010111001000101110011101000110111101010011011101000111001001101001011011100110011100101000011000110010110000110010001010010010100100101001001110110111001001100101011101000111010101110010011011100010000101100111001011100110110101100001011101000110001101101000011001010111001100101000001000100010111000101010001010000010111000101001010111000101110000110001010111000101110000110001010111000101110000110001001011100010101000100010001010010011101101111101

Solusi bitshifting lama, 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;}

Cobalah online!

Biner

011000100110111101101111011011000110010101100001011011100000101001100010001010000110001101101000011000010111001001011011010111010110001000101001011110110000101001101001011011100111010000001010011011110011110100110000001011000111000000111101001100000010110001101001001110110000101001100110011011110111001000101000011000110110100001100001011100100000101001100011001110100110001000101001011110110110011001101111011100100010100001101001001111010011000000111011011010010011110000111000001110110010100101111011011010010110011000101000001010000110001100100110001010000011000100111100001111000110100100101011001010110010100100101001001111000011000100101001011110110110111100111101001100000011101101110000001010110010101100111011011111010110010101101100011100110110010101111011011100000011110100110000001110110110111100101011001010110011101101111101011010010110011000101000001100110011110001101111011111000011001100111100011100000010100101110010011001010111010001110101011100100110111000001010001101100011110000110101001110110111110101111101011100100110010101110100011101010111001001101110000010100011010100111100001101100011101101111101

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

Catatan

Berisi satu 4-run 1s. Membutuhkan ⎕IO←0yang default pada banyak sistem. Perhatikan bahwa ini harus dijalankan pada juru bahasa Klasik sehingga string adalah satu byte per karakter.

pengajuan

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

Cobalah online!

Sumber biner

_{^{00110001101011001001110010110010100101110101110010111001001010001101011100110100010111001010100010}} 1111 _{^{001011101110101011101011011101010101010101000100010001}}

Penjelasan

⍞ Prompt untuk input string

11 ⎕DR dikonversi ke 1- bit Boolean ( 1 ) D ata R epresentation

⊂ lampirkan sehingga kami dapat menerapkan beberapa hal padanya

(... ) ⍷¨ indikator biner di mana masing-masing urutan berikut dimulai ...

 × tanda (no-op pada data biner, tetapi dimasukkan sebagai spacer untuk membagi proses)

 4 \¨ perluas (salin) masing-masing hingga empat

 ⍳ bilangan bulat hingga

 ≢ penghitungan

 ⍬⍬  daftar terdiri dari dua daftar numerik kosong

∊ minta (ratakan)

⌈\ maksimum kumulatif

⌽ membalikkan

⊃ pilih yang pertama

1 ≠ berbeda satu? (Yaitu TIDAK)

Walk-through

Kami akan memasukkan "48" ke versi un-de-runned yang tidak dikurung ~ ∨/ ∊ (0 0 0 0)(1 1 1 1) ⍷¨ ⊂ 11 ⎕DR ⍞:

11 ⎕DR ⍞ convert "48" menjadi 0 0 1 1 0 1 0 0 0 0 1 1 1 0 0 0 (yaitu Des 52 56, Hex 34 38)

(0 0 0 0)(1 1 1 1) ⍷¨ ⊂menemukan permulaan 0-run dan 1-run; (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)

∨/ ∊terlihat jika ada Kebenaran (yaitu setiap berjalan); 1

~meniadakan itu; 0

Jeli 28 + 140 kekurangan = 168

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

Penjelasan

OB

Konversi argumen ke daftar pengkodean biner mereka, misalnya

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

Bagian selanjutnya

UÇ€U

memperbaiki fakta bahwa daftar di atas dapat berupa karakter yang hilang karena Btidak termasuk nol di depan. Ç€memanggil tautan yang ditentukan sebelumnya atas setiap elemen yang mengembalikannya

L8_0xṭ

Tautan ini setara dengan

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

Sebagai contoh

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

Kami membalikkan daftar sebelum dan sesudah operasi ini (dua Upanggilan dalam daftar itu) untuk menjadikannya sebagai prepend daripada append. Bagian selanjutnya

FŒr

Ratakan daftar ( F), berikan string biner total dari pengkodean ASCII, dan run-length mengkodekan output ( Œr). Jadi misalnya

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

dan

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

Akhirnya kami memeriksa apakah setiap elemen <4 (untungnya ini selalu benar untuk 0,1) dengan

<4F

Sebagai contoh

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]

Akhirnya

Ạ

Mengembalikan 0 jika ada yang palsu (dalam hal ini, 0).

Halaman Kode

Di halaman kode Jelly kode ini adalah 20 byte tetapi memiliki 27 run senilai pelanggaran aturan. Dalam UTF-8 itu adalah 28 byte tetapi dengan hanya 14 run senilai pelanggaran.

05AB1E , 22 + 3 * 10 = 52

Disimpan 2 penalti berjalan meminjam trik delta dari jawaban Jonathan Allan's Jelly

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

Cobalah online!

Penjelasan

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

Representasi kode biner

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

3 penalti berjalan berasal dari vy¦}yang digunakan untuk memotong byte pertama di setiap string biner, tetapi masih lebih murah daripada 4 berjalan kita dapatkan dari yang lebih pendek €¦.

Perl , 33 + 160 = 193

32 byte kode + 1 byte untuk -nflag.

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

(input harus dipasok tanpa baris baru final. Tautan Coba online telah -lditandai untuk menghapus baris baru, tetapi untuk satu input, itu tidak diperlukan).

Cobalah online!

xxd dump:

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+

Beberapa catatan:

• (.)\1\1\1menghemat beberapa penalti (.)\1{3}, 1111|0{4}atau regex lain yang dapat saya pikirkan (menggunakan 0atau {}dikenakan biaya besar).
• printmenghemat ~ 8 poin lebih dari menggunakan -pdan $_=karena pmengandung jangka 4 0sementara ntidak.
• +sebagai pembatas untuk regex menyimpan menjalankan 1yang ada di /.
• melakukan dua langkah, bukan satu dengan !~menghemat dua berjalan ( ~yang 01111110dalam biner).
• unpack"B*"cukup mahal (4 berjalan), tetapi saya tidak dapat menemukan lebih murah (solusi berdasarkan ordakan lebih mahal).

PHP, 98 + 270 = 368 byte

Saya ingin mengambil pendekatan yang berbeda dari apa yang diusulkan Titus , dan diakhiri dengan program yang sedikit lebih lama, namun kurang dihukum.

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

Keluaran 1untuk kebenaran, tidak ada untuk falsey.

Coba di sini!

Disandi biner:

0010010001110110001111010111010101101110011100000110000101100011011010110010100
0001001110100100000101010001001110010110000100100011000010111001001100111011101
1001011011001100010101110100101001001110110010010001100101001111010110001001100
0010111001101100101010111110110001101101111011011100111011001100101011100100111
0100001010000010010001110110010110110011000101011101001011000011000100110110001
0110000110010001010010011101101100101011000110110100001101111001000010111001101
1101000111001001101001011100110111010001110010001010000010010001100101001011000
0100111001100000011000000110000001100000010011100101001001001100010011000100001
0111001101110100011100100110100101110011011101000111001000101000001001000110010
1001011000010011100110001001100010011000100110001001001110010100100111011

(22 kejadian 0000dan 5 kejadian 1111, karenanya 270 byte penalti)

PHP, 86 byte + 370 = 456

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

menciptakan string biner dan menggunakan regex untuk mendeteksi goresan. Output 1untuk kebenaran; kosong untuk kepalsuan.

Jalankan dengan echo '<string>' | php -nR '<code>'.

tweak

• backreferences menyimpan 100 penalti untuk 3 byte. (Skor -97)

ide-ide terlantar

• join(array_map(str_split())) akan dikenakan biaya 31 byte dan 90 penalti
• dan <?=/ $argv[1]bukannya echo/ $argnbiaya 2 + 40 lainnya.
• str_pad(decbin())lebih mahal dari sprintf: 7 byte dan 110 penalti.
• strtr menghemat 80 penalti untuk 13 byte tambahan, tetapi backreferences lebih baik.
• Pengelompokan backreferences #(.)\\1{3}menghemat 3 byte, tetapi menambahkan 10 penalti.
• foreach biaya 3 + 50.
• Tidak ada kemungkinan penghematan pada nama variabel.
• biaya buffering output 42 + 120.

MATL, 16 byte + 60 = 76 byte

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

Cobalah di MATL Online

JavaScript (ES8), 91 byte + 430 penalti = 521 total

Ini akan menampilkan 1untuk truedan 0untuk false.

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

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000010110110010111000101110001011100111001101011101001011100110110101100001011100000010100001100011001111010011111001100011001011100110001101101000011000010111001001000011011011110110010001100101010000010111010000101000001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110000011000010110010001010011011101000110000101110010011101000010100000110011001010110011010100101100001100010010110100110001001010010010100100101110011010100110111101101001011011100010100000100010001000100010100100101001

Cobalah

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

Gunakan ide Jonathan Allan untuk bekerja dengan delta.

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

Cobalah online!

Representasi biner:

00110001011100010011001000110101
00110110011000100011001001100010
00110010011001010111011100111010
00111010001011010101101101010100
01010100010101000101110100100011
001010010110011100101101

Penjelasan:

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

Biner

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

Penjelasan

!|}*"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 tidak bagus dalam mengubah string menjadi biner, tapi saya pikir saya akan memberikan tantangan ini hanya untuk bersenang-senang.

Kode:

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}

Biner:

0110011001110101011011100110001101110100011010010110111101101110001010000110111000101001011110110110001000111101001000100010001000111011011001100110111101110010001010000111011001100001011100100010000001110100001111010011000000111011011101000011110001101110001011100110110001100101011011100110011101110100011010000011101101110100001010110010101100101001011000110011110101011011011011100010111001100011011010000110000101110010010000110110111101100100011001010100000101110100001010000111010000101001001011100111010001101111010100110111010001110010011010010110111001100111001010000011001000101001010111010010110001100011001011100111010101101110011100110110100001101001011001100111010000101000010000010111001001110010011000010111100100101000001110000010110101100011010110110011000001011101001011100110110001100101011011100110011101110100011010000010101100110001001010010010111001101010011011110110100101101110001010000011000000101001001010010010110001100010001010110011110101100011001011100110101001101111011010010110111000101000001000100010001000101001001110110111001001100101011101000111010101110010011011100010000001100010001011100110110101100001011101000110001101101000001010000010111101011011001100010101110101111011001101000010110001111101011111000101101100110000010111010111101100110100001011000111110100101111011001110010100100111111001000010011000100111010001000010011000001111101

Penjelasan:

Buat string untuk bekerja dengan:

b="";

Ulangi setiap karakter dalam string:

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

Buat array dan ubah string menjadi biner menggunakan kode karakter:

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

Tambahkan nol di depan ke array:

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

Bergabung kembali dengan array menjadi string:

b+=c.join("")

Kembali apakah string empat atau lebih 1 atau 0 ditemukan dalam hasil biner menggunakan ekspresi reguler:

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

Biola:

https://jsfiddle.net/vrtLh97c/

Statistik:

Durasi: 173 bytes Hukuman: 890 Total: 1063

Golf Code sulit :)

Pyth, 21 + 2 * 10 = 41

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

Cobalah online!

Representasi biner:

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

Retina, 101 + 1390 = 1491

Kode berisi karakter yang tidak patut, tetapi muncul di Chrome jika Anda mengedit pos. -adalah \x01-\x7f.

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

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

Cobalah online

Kode iniord menggunakan ini , diikuti oleh konversi ke biner dan pemeriksaan sederhana untuk urutan yang tumpang tindih dari empat.

Dalam biner:

11000010101101100000101011000010101100010000101001010011010111110110000000001010001001010010100001010011011000001100001010110001000010100111101100110010011000000000101000100100011000000000101001111101010101000011000000110001011000000000000100101101011111110110000001011111011011110000101000101001010011010111001101100000001011100000101000101110001010110000101000100100001010100000101000101011011000000010100000110001001010110010100100000001000010100010010001111011001100010111110100110000000010100011000000110001000010100011000100001010011011010010101101100000010111100010100000111111001000010010111001111011001110000111110100101001000010100011000000001010001100000111101100111000011111010111110011000010101101100000101000001010010011010010011001100000001010000010111000101001000000010111101100110011011111010000101000110000

Hukuman dihitung dengan program Python ini .

Python 2 , 74 (panjang) + 130 (penalti) = 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

Output melalui kode keluar; 0 benar, 1 palsu. Menghasilkan keluaran sampah ke STDOUT dan STDERR.

Cobalah online!

Tempat sampah

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

Dalam biner:

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000011100110010111001110010011001010111000001101100011000010110001101100101001010000010111101011011010111000101001101011100011100110101110100101111011001110010110001100011001111010011111000101000001100100011010100110110001010110110001100101110011000110110100001100001011100100100001101101111011001000110010101000001011101000010100000101001001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110011011011000110100101100011011001010010100000110001001010010010100100101001

Lebih dari setengah penalti turun ke nol di tumpang tindih antara byte, daripada berjalan dalam karakter berikut: =>//pa//=>aCoAo .

Karena /s ( 00101111) membayar penalti, saya mencoba a) beralih dari testke matchb) beralih darireplace ke maptetapi skor selalu berakhir lebih tinggi. Namun saya menemukan bahwa [\S\s]itu adalah perbaikan [^]. Sunting: Disimpan 9 byte secara keseluruhan berkat @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

Cobalah online!

Biner

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

Trik

Pergantian berikut dilakukan untuk menghindari kekurangan:

• Menggunakan qZ(sama dengan nol) alih-alih! (meniadakan)
• Menggunakan :xy0(mencari) alih-alih }xy(adalah sublist)
• Menggunakan Z(variabel, standar ke nol) alih-alih 0(nol sendiri)

Perbaikan

Saya tidak menemukan cara untuk menghindari hukuman. Kami memiliki perintah ini terkait dengan biner:

• .Bbiner ( 00101110 01[0000]10)
• Ckode sandi ( 01[0000]11)
• .Ooctary ( 00101110 0100[1111])
• .Hheksadesimal ( 00101110 01001[000)

Catatan yang .Hjuga akan memberi kita penalti, karena setiap karakter yang dapat dicetak memiliki representasi biner dimulai dengan 0. Karena itu, saya menggunakan yang paling langsung, yaitu.B , langsung mengubahnya menjadi biner.

Saya bisa mengakhiri dengan .H untuk menghindari penalti, tetapi harganya 27 byte ...

Generasi

Saya menemukan semua karakter yang dibolehkan, yaitu yang tidak mengandung 0000atau 1111, dan yang tidak diakhiri dengan 000(karena karakter selanjutnya harus dimulai dengan 0):

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

Berikut adalah karakter yang diakhiri dengan 1000. Mereka hanya dapat digunakan di akhir:

• (8HXhx