Ваша задача: по заданной входной строке определить, не содержит ли двоичное представление этой строки 4 1или 5 0строк подряд. Кроме того, сам ваш код не должен содержать ни одной такой серии из четырех строк подряд.

Тестовые случаи

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 1с или 0с считается как два прогона, 6 подряд считается за три прогона и т. Д.
• На входе будет строка или массив символов, а не любая другая форма.
• Вы можете написать полную программу или функцию.
• Вы должны предоставить двоичное представление вашего кода в своем ответе.

Удачи, выигрывает самая низкая оценка!

Этот сценарий может помочь вам в решении вашей задачи, поместить ваш код во входные данные и даст вам двоичное представление вашего кода, его длину, ваш штраф и общую оценку, если вы используете UTF-8.

Leaderboard

Вот фрагмент стека, чтобы генерировать как регулярную таблицу лидеров, так и обзор победителей по языкам.

/* 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если в представлении 8-битных слов в строке ввода ASCII нет равных битовых строк длиной 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(приравнивая нули и единицы к равным), и искать любое вхождение трех нулей подряд. Для этого я преобразовал все нули в единицы с помощью биномиальной функции с 2cт. Е. 2Cx - чтобы -1s стало 0s, 1s стало 2s, а 0s стало1S; таким образом код может искать первое вхождение подсписка [1,1,1]с помощью w111.
  Однако более короткий путь стал очевидным - чтобы имитировать действие «всех перекрывающиеся ломтики заданной длины», ṡможно использовать 4 -wise перекрывающих уменьшают с некоторой диадой, <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. Теперь последний тест - просто проверить, есть ли какие-либо 0s в списке, достижимые непосредственно с помощью монады Ạ.

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 во входной строке находится в начальных нулях самого первого символа - эти символы: табуляция; линии корма; и возврат каретки. Без этого преобразование base 256 эффективно удаляет начальные нули из (полностью сцепленной) двоичной строки; с ведущими 2 там будут ведущие нули и еще один с нулем перед ними. Поскольку ни один из печатаемых 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 байт

Заметки

Содержит одну 4-х серийную 1с. Требуется ⎕IO←0по умолчанию во многих системах. Обратите внимание, что это должно быть выполнено в интерпретаторе Classic, чтобы строки составляли один байт на символ.

представление

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

Попробуйте онлайн!

Двоичный источник

_{^{001100011010110010011100101100101001011101011100101110010010100011010111001101000101110010101010111001010100010}} 1111 _{^{0010111011101010111010110010100110111010101010001001101100010001001100100000001001100010001100010001000101}}

объяснение

⍞ Запрос на ввод строки

11 ⎕DR преобразовать в 1 битовое Boolean ( 1 ) D ата R 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 (т.е. 52 декабря 56, шестнадцатеричное 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)

∨/ ∊смотрит, есть ли Истина (то есть, работает); 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

Сглаживает list ( 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 серии пенальти, заимствуя дельта- трюк из Jelly ответа Джонатана Аллана

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

Несколько заметок:

• (.)\1\1\1сохраняет несколько штрафов более (.)\1{3}, 1111|0{4}или любое другое регулярное выражение я мог думать ( с использованием 0или {}поставляется по цене тяжелой).
• printэкономит ~ 8 баллов за использование -pи $_=потому что pсодержит пробег 4, 0а nне.
• +в качестве разделителя для регулярного выражения сохраняет ряд того, 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>'.

твики

• обратные ссылки сохраняют 100 штрафов за 3 байта. (-97 баллов)

заброшенные идеи

• join(array_map(str_split())) будет стоить 31 байт и 90 штрафов
• и <?=/ $argv[1]вместо echo/ $argnстоит еще 2 + 40.
• str_pad(decbin())стоит дороже sprintf: 7 байтов и 110 штрафов.
• strtr сохраняет 80 штрафов за 13 дополнительных байтов, но обратные ссылки лучше.
• Группировка обратных ссылок #(.)\\1{3}экономит 3 байта, но добавляет 10 штрафов.
• foreach стоит 3 + 50.
• Сохранение невозможно в именах переменных.
• выходная буферизация стоит 42 + 120.

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.

Пиф, 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}

Binary:

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

Вернуть, была ли найдена строка из четырех или более единиц или 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 , затем следует преобразование в двоичный файл и простая проверка на перекрывающиеся последовательности из четырех.

В двоичном виде:

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б) переключиться с replaceна, mapно счет всегда заканчивался выше. Однако я обнаружил, что [\S\s]это улучшение по сравнению с [^]. Изменить: Сохранено 9 байтов в целом благодаря @Shaggy.

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