Ваше завдання: задавши рядок введення, визначте, чи немає в двійковому представленні цього рядка 4 1s або 0s підряд ніде. Крім того, сам код не повинен містити таких циклів із чотирьох підряд.

Випробування

String      Binary              Result

U3          01010101 00110011   Truthy

48          00110100 00111000   Falsy

Foobar      01000110 01101111   Falsy
            01101111 01100010
            01100001 01110010

Feeber      01000110 01100101   Truthy
            01100101 01100010
            01100101 01110010

$H          00100100 01001000   Truthy

<Empty>     -                   Truthy

Правила

Введення завжди буде в межах діапазону для друку ASCII, включаючи символи пробілу.
- Ваш код може використовувати будь-яке кодування, оскільки воно має значення лише на рівні бітів.
Оскільки ця умова перешкоджає використанню пробілу та багатьох інших символів, ваш код насправді може містити такі прогони з чотирьох підряд, при 10-байтному покаранні за кожен пробіг.
- Пробіг 5 1с або 0с вважається двома пробіжками, 6 підряд вважається трьома пробіжками тощо.
Введенням буде масив рядків чи знаків, а не будь-яка інша форма.
Ви можете написати повну програму або функцію.
Ви повинні вказати двійкове представлення свого коду у своїй відповіді.

Удачі, найнижчий рахунок виграє!

Цей скрипт може допомогти вам у вирішенні проблем, введіть свій код у вхід, і він дасть вам двійкове представлення вашого коду, його довжину, ваш штраф та загальний бал, якщо ви використовуєте 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>

Розгорніть фрагмент

— Павло
джерело

1

Я майже впевнений, що фрагмент баггі, наприклад, я бачу ||перелічені, і це 0111110001111100.

— Ørjan Johansen

Правильно, хороший пункт. Одна секунда.

— Павло

2

Було б ще веселіше, якби завдання було знайти партитуру рядка.

— Adám

1

@JonathanAllan добре, як я це задумав, так і є, але після подальшого роздуму я не бачу причини для цього, тому я його зміню.

— Павло

1

@Pavel Оцінка базується не лише на байтах, якщо є пенальті. Це робить його [code-challenge], а не [code-golf]. З вікі тега: "Якщо довжина вихідного коду не є основним критерієм оцінювання, розгляньте замість цього інший тег." TL; DR, оскільки фактичний бал = / = кількість байтів програми та найкоротший код не означає отримання найкращого балу, це не [code-golf].

— mbomb007

19

Желе , 18 байт + 0 штрафних санкцій = 18

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

Повертає, 1якщо немає 8 рівних бітових рядків довжиною 4 або більше у 8-бітовому поданні слова вхідного рядка ASCII та 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 1, стати 2s, а 0s стати1s; Таким чином , код може виглядати для першого входження подсписка [1,1,1]з w111.
Однак більш короткий шлях став очевидним - щоб імітувати дію «всіх перекриваються скибочки заданої довжини», ṡможна використовувати 4 -wise перекривають зменшують з деякою діадою, <dyad>4\. Якщо це виконується з додаванням, +4\він рахує 1s, тож будь-який 0або 4присутній є індикатором для повернення значення "truthy". Проблема тут в тому , що наступний очевидний крок повинен був би взяти по модулю 4 того , що поставити 0і 4записи на рівних, залишаючи інші можливі значення ( 1, 2і 3) без змін, але +\%4має\%всередині, який має бітове значення 010111 0000 100100. Для того щоб уникнути цього штрафу числа, перетворюється в базу 4 з b4(відображення 0на [0], 1щоб [1], 2щоб [2], 3щоб [3]і 4в [1,0]) і весь список уплощен з F. Тепер останній тест - просто перевірити, чи є 0в списку якісь 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 провідні нулі будуть там, а додаткові один і нуль перед ними. Оскільки жоден ASCII для друку не має точно трьох провідних нулів, немає необхідності відмовлятися від цих зайвих бітів до початку перевірки.

— Джонатан Аллан
джерело

Я припускаю, що ви можете просто додати заперечення чи щось подібне, щоб відповідати Значенню, яке ви виводите / повертаєте для правди і фальшивості, повинно бути послідовним, що я трактую як "однакове значення кожного разу для триути" і те саме для помилки. Також ваша правда / хибність є протилежною тому, що йдеться у питанні.

— Емінья

Я просто запитав про це - коли я спочатку прочитав це (багато годин тому), я взяв "Значення, яке ви отримуєте / повертаєте за правду і хибність, має бути послідовною". означає, що ми можемо виводити в будь-який інший спосіб, поки він залишився однаковим між пробіжками ... Негативний напрямок прямого руху вперед спричинить недоліки.

— Джонатан Аллан

Я б точно міг зберегти і деякі, якщо мені цього не потрібно робити. До нової версії, над якою працюю, дуже низький бал. Я сподіваюся, що ви правильно трактуєте :)

— Emigna

Ну, я дав двобайтовий суфікс, який виконує трюк, даючи і те саме, що і приклади, і строго узгоджені значення, 0і 1якщо це потрібно.

— Джонатан Аллан

Приємно. З нетерпінням чекаю, як ви це зробили. Я

— опускаюся

12

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

— Шукати
джерело

Гарний трюк з новими рядками. Підрахунок 00000/ 11111як два прогони, 000000/ 111111як три тощо. Я рахую 101 пробіг.

— ETHproductions

@ETHproductions Виправлено

— Poke

Це має просто перемогти, оскільки Java ніколи для цього не призначена

— Крістофер

10

APL (Dyalog Classic) , 26 + 1 × 10 = 36 байт

Примітки

Містить один 4-х запуск 1 сек. Потрібно, ⎕IO←0що для багатьох систем за замовчуванням. Зауважте, що це має бути запущено на класичному інтерпретаторі, щоб рядки були одним байтом на символ.

Подання

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

Спробуйте в Інтернеті!

Бінарне джерело

_{^{00110001101011001001110010110010100101110101110010111001001010001101011100110100010111001010100010}} 1111_{^{0010111011101010111010110010100110111010101010001001101100110001001100011000110001000100010100101101101010101011011011010101010110110110101010101101101101010101011011010101010101101}}

Пояснення

⍞ Запрошення для введення рядків

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

∨/ ∊виглядає, чи є якась Правда (тобто якісь біги); 1

~заперечує це; 0

— Адам
джерело

4

Желе 28 + 140 демерів = 168

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

Пояснення

OB

Перетворює аргумент у список їх бінарних кодувань, наприклад

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

Наступний твір

UÇ€U

виправляє той факт, що у наведеному списку можуть бути відсутні символи, оскільки Bвони не включають провідні нулі. Ç€викликає визначений раніше посилання над кожним елементом, який його відновлює

L8_0xṭ

Це посилання еквівалентно

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

Наприклад

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

Ми додаємо список до та після цієї операції (два Uдзвінки в цьому списку), щоб отримати їх більше, ніж додаток. Наступний твір

FŒr

Вирівнюється список ( F), надаючи загальну двійкову рядок кодування ASCII, а довжина виконання кодує вихід ( Œr). Так, наприклад

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

і

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

Нарешті ми перевіряємо, чи кожен елемент <4 (на щастя, це завжди відповідає 0,1)

<4F

Наприклад

L8_0xṭ
“U3”OBUÇ€UFŒr<4F -> [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

Нарешті

Ạ

Повертає 0, якщо будь-який із них є помилковим (у цьому випадку 0).

Сторінки коду

На кодовій сторінці Jelly цей код становить 20 байтів, але має 27 прогонів, що порушують правила. У UTF-8 це 28 байт, але порушення мають лише 14 пробігів.

— валятися
джерело

3

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 прогони, які ми отримаємо від коротших €¦.

— Емінья
джерело

@JonathanAllan: Я згадую про це трохи наприкінці (але не докладно), але, на жаль, бінарне представлення €CP-1252 - це те, 10000000що передбачає штраф 4 в собі.

— Емінья

Ах, так ти і роби! ... і мій код Python для отримання представництва був неправильним, оскільки я помістив # coding: cp1252вгорі> _ <

— Джонатан Аллан

3

Перл , 33 + 160 = 193

32 байти коду + 1 байт для -nпрапора.

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

(вхід повинен бути наданий без остаточного нового рядка. Посилання " Спробуйте в Інтернеті " містить -lпрапор для видалення нових рядків, але для одного введення воно не потрібно).

Спробуйте в Інтернеті!

xxd дамп:

00000000: 00100100 01011111 00111101 01110101 01101110 01110000  $_=unp
00000006: 01100001 01100011 01101011 00100010 01000010 00101010  ack"B*
0000000c: 00100010 00111011 01110000 01110010 01101001 01101110  ";prin
00000012: 01110100 00100001 01101101 00101011 00101000 00101110  t!m+(.
00000018: 00101001 01011100 00110001 01011100 00110001 01011100  )\1\1\
0000001e: 00110001 00101011                                      1+

Кілька приміток:

(.)\1\1\1заощаджує кілька штрафних санкцій (.)\1{3}, 1111|0{4}або будь-який інший регекс, про який я міг би придумати (використання 0чи {}отримання великої вартості).
printекономить ~ 8 балів при використанні -pі $_=тому, що pмістить пробіг у 4, 0а nне.
+як роздільник для регулярного вираження економить пробіг того, 1що знаходиться в /.
робити два кроки замість одного із !~збереженням двох прогонів ( ~є 01111110двійковим).
unpack"B*"є досить дорогим (4 тижні), але я не зміг знайти дешевше (рішення на базі ordбуде ще дорожче).

— Дада
джерело

3

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 байт штрафу)

— roberto06
джерело

2

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.

— Тіт
джерело

Додати §в for(§;для -9.

— Крістоф

2

MATL, 16 байт + 60 = 76 байт

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

Спробуйте в MATL Online

— Сьювер
джерело

2

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

Розгорніть фрагмент

— Кудлатий
джерело

padStartне в ES6.

— Ніл

Блін! Я постійно забуваю змінювати ES8 кожного разу, коли я його використовую (те саме і з ES7 та Array.includes()) - спасибі, @Neil.

— Кудлатий

1

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.

— Мартін Ендер
джерело

1

Піта, 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

— Уріель
джерело

1

JavaScript, 173 + 89 * 10 = 1063

JavaScript не дуже хороший у перетворенні рядків у бінарне, але я подумав, що я б вирішив це завдання просто заради задоволення.

Код:

function(n){b="";for(var t=0;t<n.length;t++)c=[n.charCodeAt(t).toString(2)],c.unshift(Array(8-c[0].length+1).join(0)),b+=c.join("");return b.match(/[1]{4,}|[0]{4,}/g)?!1:!0}

Двійковий:

0110011001110101011011100110001101110100011010010110111101101110001010000110111000101001011110110110001000111101001000100010001000111011011001100110111101110010001010000111011001100001011100100010000001110100001111010011000000111011011101000011110001101110001011100110110001100101011011100110011101110100011010000011101101110100001010110010101100101001011000110011110101011011011011100010111001100011011010000110000101110010010000110110111101100100011001010100000101110100001010000111010000101001001011100111010001101111010100110111010001110010011010010110111001100111001010000011001000101001010111010010110001100011001011100111010101101110011100110110100001101001011001100111010000101000010000010111001001110010011000010111100100101000001110000010110101100011010110110011000001011101001011100110110001100101011011100110011101110100011010000010101100110001001010010010111001101010011011110110100101101110001010000011000000101001001010010010110001100010001010110011110101100011001011100110101001101111011010010110111000101000001000100010001000101001001110110111001001100101011101000111010101110010011011100010000001100010001011100110110101100001011101000110001101101000001010000010111101011011001100010101110101111011001101000010110001111101011111000101101100110000010111010111101100110100001011000111110100101111011001110010100100111111001000010011000100111010001000010011000001111101

Пояснення:

Створіть рядок для роботи з:

b="";

Петля над кожним символом у рядку:

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

Створіть масив і перетворіть рядок у двійковий, використовуючи код символу:

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

Додайте до масиву провідні нулі:

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

Приєднайте масив назад до рядка:

b+=c.join("")

Повернути, чи було знайдено рядок з чотирьох або більше 1-х чи 0-х у двійковому результаті, використовуючи регулярний вираз:

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

Fiddle:

https://jsfiddle.net/vrtLh97c/

Статистика:

Довжина: 173 байт Штраф: 890 Разом: 1063

Код гольфу важкий :)

— StephenRios
джерело

Чи можете ви надати двійкове представлення свого коду та документувати штрафи?

— Павло

Це штраф у 890 за загальний бал 1063.

— Павло

Додано підсумків до початкової публікації.

— StephenRios

1

Використання 1-1замість 0кількох місць може заощадити деякі недоліки.

— Поп

1

Піта, 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

— notjagan
джерело

1

Сітківка, 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 .

— mbomb007
джерело

Будь ласка, надайте шістнадцятковий і двійкове представлення, оскільки воно містить недруковані версії.

— Павло

Я вже сказав, що / де є недруковані файли, а також пропоную програму, яка може надрукувати двійковий рядок (коментувати рядок внизу).

— mbomb007

Добре, тоді ..

— Павло

1

Пітон 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

— Денніс
джерело

Я виявив, що 0включати досить погано. Краще використовувати1-1

— Poke

@Poke Я щойно зрозумів свою помилку. Результат невикористаний, тому я не впевнений, чому я вибрав 0в першу чергу.

— Денніс

1

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.

Оскільки /я ( 00101111) сплачував пені, я намагався: а) переходити testна " matchб", "переходити replaceна", mapале оцінка завжди закінчувалася вище. Однак я виявив, що це [\S\s]було покращенням [^]. Редагувати: Загалом збережено 9 байт завдяки @Shaggy.

— Ніл
джерело

Я думаю, що |в класі персонажів там не повинно бути

— ETHproductions

@ETHproductions Я зрозумів це правильно в своєму поясненні ...

— Ніл

Ви можете збрити 10 від вашого покарання, замінивши !з 1-в цілому 468. І ви могли б зробити додаткову економію в 5 байт, замінюючи [\S\s]з .в цілому 463.

— Shaggy

@Shaggy Дякую, хоча я не впевнений, чи вважаються новинки для друку, тому зараз я буду в безпечному режимі.

— Ніл

Чи підтримує js багаторядковий прапор регулярного виразу? Якщо так, ви можете прийняти пропозицію Шаггі і додати прапор, щоб зберегти байти.

— Павло

1

Pyth , 16 + 1 х 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)
Ccharcode ( 01[0000]11)
.Ooctary ( 00101110 0100[1111])
.Hшістнадцятковий ( 00101110 01001[000)

Зауважте, що .Hце також призведе до нас штрафу, оскільки кожен символ, який можна друкувати, має своє двійкове представлення, починаючи з цього 0. Тому я використовував найбільш прямий, а саме - .Bбезпосередньо перетворюючи його у бінарний.

Я можу закінчитись, .Hщоб уникнути штрафу, але це коштує мені 27 байт ...

Покоління

Я знайшов усі дозволені символи, які не містять 0000або 1111не закінчуються 000(оскільки наступний символ повинен починатися з 0):

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

Ось символи, які закінчуються 1000. Їх можна використовувати лише в кінці:

(8HXhx

— Лина монахиня
джерело

Від'єднайте 4 біти

Випробування

Правила

Таблиця лідерів

Желе , 18 байт + 0 штрафних санкцій = 18

Як?

Java 7, 812 726 673 644 634 616 599 588 145 байт + 10 * 44 = 585

Двійкові

Старий розчин бітшифтингу 141 байт + 10 * 101 = 1,151

Двійкові

APL (Dyalog Classic) , 26 + 1 × 10 = 36 байт

Примітки

Подання

Бінарне джерело

Пояснення

Прохідна

Желе 28 + 140 демерів = 168

Пояснення

Сторінки коду

05AB1E , 22 + 3 * 10 = 52

Перл , 33 + 160 = 193

PHP, 98 + 270 = 368 байт

PHP, 86 байт + 370 = 456

MATL, 16 байт + 60 = 76 байт

JavaScript (ES8), 91 байт + 430 штрафних санкцій = 521 всього

Спробуй це

CJam , 23 байти

Піта, 19 + 12 * 10 = 139

Двійкові

Пояснення

JavaScript, 173 + 89 * 10 = 1063

Код:

Двійковий:

Пояснення:

Fiddle:

Статистика:

Піта, 21 + 2 * 10 = 41

Сітківка, 101 + 1390 = 1491

Пітон 2 , 74 (довжина) + 130 (пенальті) = 204

Бінарний смітник

JavaScript (ES6), 87 88 + 390 380 = 477 468 байт

Pyth , 16 + 1 х 10 = 26 байт

Двійкові

Витівки

Поліпшення

Покоління