Twoje zadanie: biorąc pod uwagę ciąg wejściowy, określ, czy reprezentacja binarna tego ciągu nie ma nigdzie w wierszu 4 1sekund lub 0sekund. Co więcej, sam kod nie powinien zawierać żadnych takich ciągów po cztery z rzędu.

Przypadki testowe

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

Zasady

Dane wejściowe zawsze będą się mieścić w zakresie drukowanych znaków ASCII, w tym białych znaków.
- Twój kod może używać dowolnego kodowania, ponieważ ma on znaczenie tylko na poziomie bitów.
Ponieważ ten warunek uniemożliwia użycie spacji i wielu innych znaków, twój kod może faktycznie zawierać takie przebiegi po cztery z rzędu, z 10 bajtową karą za każdy przebieg.
- Przebieg 5 1s lub 0s liczy się jako dwa przebiegi, 6 z rzędu liczy się jako trzy przebiegi itp.
Dane wejściowe będą tablicą łańcuchów znaków lub znaków, a nie żadną inną formą.
Możesz napisać pełny program lub funkcję.
Musisz podać binarną reprezentację swojego kodu w swojej odpowiedzi.

Powodzenia, wygrywa najniższy wynik!

Ten skrypt może pomóc ci w podjęciu wyzwania, wstawić kod do danych wejściowych, a otrzymasz binarną reprezentację kodu, jego długość, karę i całkowity wynik, jeśli używasz UTF-8.

Tabela liderów

Oto fragment kodu, który pozwala wygenerować zarówno zwykłą tabelę wyników, jak i przegląd zwycięzców według języka.

Pokaż fragment kodu

/* 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>

Rozwiń fragment kodu

— Pavel
źródło

1

Jestem prawie pewien, że fragment kodu jest błędny, np. Widzę, ||że jest na liście i to znaczy 0111110001111100.

— Ørjan Johansen

Racja, dobra uwaga. Sekundę.

— Pavel

2

Byłoby jeszcze fajniej, gdyby zadaniem było znalezienie partytury struny.

— Adám

1

@JonathanAllan dobrze, tak jak zamierzałem, tak jest, ale po dalszej refleksji nie widzę powodu, więc zmienię to.

— Pavel

1

@Pavel Punktacja nie opiera się wyłącznie na bajtach, jeśli istnieją kary. To sprawia, że jest to [wyzwanie kodowe], a nie [golf golfowy]. Z tagu wiki: „Jeśli długość kodu źródłowego nie jest podstawowym kryterium oceny, rozważ użycie innego tagu”. TL; DR, ponieważ faktyczny wynik = / = liczba bajtów programu, a najkrótszy kod nie oznacza uzyskania najlepszego wyniku, nie jest to [code-golf].

— mbomb007

19

Galaretka , 18 bajtów + 0 kar = 18

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

Zwraca, 1jeśli nie ma równych ciągów bitów o długości 4 lub więcej w 8-bitowej reprezentacji słów wejściowych ciągu ASCII, i w 0przeciwnym razie.

Wypróbuj online! (pakiet testowy z dodanymi dodatkowymi przypadkami)

Za pomocą strony kodowej Jelly nie ma podciągów o długości 4 lub dłuższych równych bitów:

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

Przy równych bitach długości:

221323221211111312322133122121221111213121123132213111122211311332313211313211111112

W jaki sposób?

Sztuczki pozwalające uniknąć wad są:

aby uniknąć „Convert z charakterem do porządkowej” monady Oprzekształcając liczbę 79na postać używająca Ọnastępnie przez „oceny kodu Jelly z wejściem” v.
aby uniknąć bezpośredniej konwersji na binarną przy użyciu B( 0x42, 1000010) przez prostą dwubajtową alternatywę b2przy użyciu ogólnej konwersji zasady diadadowej.
aby uniknąć kilku normalnych wyborów do zliczania serii równych bitów - pierwszym wyborem byłyby „wszystkie nakładające się plasterki o danej długości”, ṡ( 0xF5lub 11110101). Drugim wyborem może być wykorzystanie „wszystkich podlist”, Ẇ( 0xCFlub 11001111).
Obejście, którego użyłem przed bieżącym, polegało na przyjmowaniu przyrostów (między kolejnymi elementami) za pomocą I(umieszczanie zer i jedynek na równych stopach) oraz poszukiwanie dowolnego wystąpienia trzech zer z rzędu. Aby to zrobić, przekonwertowałem wszystkie zera na jedynki za pomocą funkcji dwumianowej z 2cnp. 2Cx - co powoduje, że -1s staje 0się 1s staje się 2s, a 0s staje się1s; w ten sposób kod może wyszukać pierwsze wystąpienie podlisty [1,1,1]z w111.
Jednakże krótszy sposób okazało się, - do naśladowania działania „wszystkie zachodzące na siebie kawałkami danej długości”, ṡmożna użyć 4 -wise nakładający zmniejszyć niektóre diadę, <dyad>4\. Jeśli jest to wykonywane z dodaniem, +4\to zlicza 1s, więc każdy 0lub 4obecność jest wskaźnikiem zwracającym prawdziwą wartość. Problem jest to, że obok oczywistym krokiem byłoby podjąć modulo 4 tego umieścić 0i 4wpisy na równi pozostawiając inne możliwe wartości ( 1, 2, i 3) na niezmienionym poziomie, ale +\%4ma\%środka, który ma wartość bitową 010111 0000 100100. W celu uniknięcia tej kary numery są przekształcane do podstawy 4, z b4(mapowanie 0do [0], 1z [1], 2w celu [2], 3z [3]i 4do [1,0]) i całość liście są spłaszczone F. Teraz ostatnim testem jest po prostu sprawdzenie, czy 0na liście są jakieś litery, które można osiągnąć bezpośrednio za pomocą monady Ạ.

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?

Uwaga: Powodem, dla którego liczba 2 jest powiązana z listą porządkową, jest zajmowanie się przypadkami krawędzi, w których jedyny ciąg 4 w ciągu wejściowym znajduje się w zerach wiodących pierwszego znaku - te znaki to: tab; linijka; i zwrot karetki. Bez tego podstawowa konwersja 256 skutecznie usuwa wiodące zera z (w pełni skonkatenowanego) ciągu binarnego; z wiodącymi 2 wiodącymi zerami będą tam, a przed nimi jeszcze jeden i zero. Ponieważ żaden ASCII do wydrukowania nie ma dokładnie trzech zer wiodących, nie trzeba odrzucać tych dodatkowych bitów przed resztą kontroli.

— Jonathan Allan
źródło

Zakładam, że możesz po prostu dodać negację lub coś podobnego, aby zachować zgodność . Wartość, którą wyprowadzasz / oddajesz dla prawdy i fałszu, musi być spójna, co interpretuję jako „tę samą wartość za każdym razem dla prawdy” i taką samą dla fałszu. Również twoje prawda / fałsz jest przeciwne do tych w pytaniu.

— Emigna

Właśnie o to zapytałem - kiedy go przeczytałem (wiele godzin temu), wziąłem: „Wartość, którą wyprowadzasz / oddajesz za prawdę i fałsz, musi być spójna”. oznacza to, że możemy wyprowadzać dane w obie strony, pod warunkiem, że pozostaną takie same między kolejnymi seriami ... Prosta negacja spowoduje odroczenie.

— Jonathan Allan

Z pewnością mógłbym też trochę uratować, jeśli nie muszę tego robić. Do bardzo niskiego wyniku w nowej wersji, nad którą pracuję. Mam nadzieję, że to ty poprawnie zinterpretowałem :)

— Emigna

Cóż, podałem dwubajtowy sufiks, który załatwia sprawę, podając oba te same sposoby jak w przykładach i ściśle spójne wartości 0i, 1jeśli to konieczne.

— Jonathan Allan

Miły. Nie mogę się doczekać, aby zobaczyć, jak to zrobiłeś.

— Zejdę

12

Java 7, 812 726 673 644 634 616 599 588 145 bajtów + 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.*");}

Używam znaku nowej linii zamiast spacji, aby zminimalizować kary ...

Wypróbuj online!

Dwójkowy

01100010011011110110111101101100011001010110000101101110000010100110001000101000011000110110100001100001011100100101101101011101011000100010100101111011010100110111010001110010011010010110111001100111000010100110011100111101001000100010001000111011011001100110111101110010001010000110001101101000011000010111001000001010011000110011101001100010001010010110011100101011001111010110011100101110011001100110111101110010011011010110000101110100001010000010001000100101001000100010101100101000001100010010110100110001001010010010101100100010001110000110010000100010001011000110111001100101011101110000101001001001011011100111010001100101011001110110010101110010001010000100100101101110011101000110010101100111011001010111001000101110011101000110111101010011011101000111001001101001011011100110011100101000011000110010110000110010001010010010100100101001001110110111001001100101011101000111010101110010011011100010000101100111001011100110110101100001011101000110001101101000011001010111001100101000001000100010111000101010001010000010111000101001010111000101110000110001010111000101110000110001010111000101110000110001001011100010101000100010001010010011101101111101

Stare rozwiązanie przesunięcia bitów 141 bajtów + 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;}

Wypróbuj online!

Dwójkowy

011000100110111101101111011011000110010101100001011011100000101001100010001010000110001101101000011000010111001001011011010111010110001000101001011110110000101001101001011011100111010000001010011011110011110100110000001011000111000000111101001100000010110001101001001110110000101001100110011011110111001000101000011000110110100001100001011100100000101001100011001110100110001000101001011110110110011001101111011100100010100001101001001111010011000000111011011010010011110000111000001110110010100101111011011010010110011000101000001010000110001100100110001010000011000100111100001111000110100100101011001010110010100100101001001111000011000100101001011110110110111100111101001100000011101101110000001010110010101100111011011111010110010101101100011100110110010101111011011100000011110100110000001110110110111100101011001010110011101101111101011010010110011000101000001100110011110001101111011111000011001100111100011100000010100101110010011001010111010001110101011100100110111000001010001101100011110000110101001110110111110101111101011100100110010101110100011101010111001001101110000010100011010100111100001101100011101101111101

— Szturchać
źródło

Niezła sztuczka z nowymi liniami. Licząc 00000/ 11111jako dwa przebiegi, 000000/ 111111jako trzy itd. Liczę 101 przebiegów łącznie.

— ETHprodukcje

@ETHproductions Naprawiono

— Poke

To powinno po prostu wygrać, ponieważ Java nigdy nie była do tego przeznaczona

— Christopher

10

APL (Dyalog Classic) , 26 + 1 × 10 = 36 bajtów

Notatki

Zawiera jeden 4-biegowy 1s. Wymaga ⎕IO←0ustawienia domyślnego w wielu systemach. Zauważ, że należy to uruchomić w klasycznym interpretatorze, aby łańcuchy były jednym bajtem na znak.

Uległość

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

Wypróbuj online!

Źródło binarne

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

Wyjaśnienie

⍞ Monituj o ciąg znaków

11 ⎕DR konwertuj na 1- bitową wartość logiczną ( 1 ) D ata R eprezentacja

⊂ dołącz, abyśmy mogli zastosować do niego wiele rzeczy

(… ) ⍷¨ Wskaźniki binarne, od których zaczyna się każda z następujących sekwencji…

× znak (brak operacji na danych binarnych, ale dołączony jako odstępnik do podzielonych przebiegów)

4 \¨ rozwiń (skopiuj) każdy do długości czterech

⍳ liczby całkowite do

≢ suma z

⍬⍬ lista składająca się z dwóch pustych list numerycznych

∊ zaciągnąć się (spłaszczyć)

⌈\ łączne maksimum

⌽ rewers

⊃ wybierz pierwszy

1 ≠ jest inny od? (tj. NIE)

Walk-through

Wprowadzimy „48” do nieoznakowanej, nie uruchomionej wersji ~ ∨/ ∊ (0 0 0 0)(1 1 1 1) ⍷¨ ⊂ 11 ⎕DR ⍞:

11 ⎕DR ⍞ konwertuje „48” na 0 0 1 1 0 1 0 0 0 0 1 1 1 0 0 0 (tj. 52 grudnia 56, heks. 34 38)

(0 0 0 0)(1 1 1 1) ⍷¨ ⊂znajduje początki 0 przebiegów i 1 przebiegów; (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)

∨/ ∊sprawdza, czy istnieje jakakolwiek Prawda (tzn. jakikolwiek bieg); 1

~neguje to; 0

— Adám
źródło

4

Galaretka 28 + 140 demeritów = 168

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

Wyjaśnienie

OB

Konwertuje argument na listę ich kodowań binarnych, np

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

Następny kawałek

UÇ€U

naprawia fakt, że na powyższej liście mogą brakować znaków, ponieważ Bnie zawiera zer wiodących. Ç€wywołuje uprzednio zdefiniowany link nad każdym elementem, który to przywraca

L8_0xṭ

Ten link jest równoważny z

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

Na przykład

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

Podnosimy listę przed i po tej operacji (dwa Uwywołania na tej liście), aby była to przedrostek, a nie dodatek. Następny kawałek

FŒr

Spłaszcza listę ( F), podając całkowity ciąg binarny kodowania ASCII, a długość przebiegu koduje wyjście ( Œr). Na przykład

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

i

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

Na koniec sprawdzamy, czy każdy element ma wartość <4 (na szczęście jest to zawsze prawda dla 0,1) za pomocą

<4F

Na przykład

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]

Wreszcie

Ạ

Zwraca 0, jeśli którykolwiek z nich jest fałszem (w tym przypadku 0).

Strony kodowe

Na stronie kodowej Jelly ten kod ma 20 bajtów, ale ma 27 przypadków naruszenia reguł. W UTF-8 jest to 28 bajtów, ale naruszenia dotyczą tylko 14 serii.

— walpen
źródło

3

05AB1E , 22 + 3 * 10 = 52

Zaoszczędzono 2 rzuty karne pożyczając trik delta od odpowiedzi galaretki Jonathana Allana

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

Wypróbuj online!

Wyjaśnienie

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

Binarna reprezentacja kodu

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

Pochodzą 3 biegi karne, z vy¦}których odciąga się pierwszy bajt w każdym ciągu binarnym, ale wciąż jest tańszy niż 4 biegi, które otrzymamy od krótszego €¦.

— Emigna
źródło

@JonathanAllan: Wspominam o tym trochę na końcu (ale nie szczegółowo), ale niestety binarna reprezentacja €w CP-1252 10000000sama w sobie powoduje karę 4.

— Emigna

Ach, więc tak! ... a mój kod Pythona do uzyskania reprezentacji był niepoprawny, gdy umieściłem # coding: cp1252na górze> _ <

— Jonathan Allan

3

Perl , 33 + 160 = 193

32 bajty kodu + 1 bajt na -nflagę.

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

(dane wejściowe należy podać bez końcowej nowej linii. Link Wypróbuj online ma -lzaznaczoną flagę, aby usunąć nowe linie, ale w przypadku pojedynczego wejścia nie jest to konieczne).

Wypróbuj online!

zrzut 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+

Kilka uwag:

(.)\1\1\1oszczędza kilka kar nad (.)\1{3}, 1111|0{4}lub dowolny inny regex mogę myśleć (z użyciem 0lub {}przychodzi kosztem ciężkich).
printpozwala zaoszczędzić ~ 8 punktów podczas używania, -pa $_=ponieważ pzawiera ciąg 4, 0podczas gdy nnie.
+jako ogranicznik wyrażenia regularnego zapisuje ciąg, 1który jest w /.
wykonanie dwóch kroków zamiast jednego z !~zapisaniem dwóch przebiegów ( ~jest 01111110w formacie binarnym).
unpack"B*"jest dość drogi (4 przebiegi), ale nie mogłem znaleźć tańszego (rozwiązania oparte na rozwiązaniach ordbędą jeszcze droższe).

— Dada
źródło

3

PHP, 98 + 270 = 368 bajtów

Chciałem przyjąć inne podejście niż to, co zaproponował Tytus , i zakończyłem nieco dłuższym, ale mniej karanym programem.

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

Wyjścia 1dla prawdy, nic dla falsey.

Wypróbuj tutaj!

Kodowane binarnie:

0010010001110110001111010111010101101110011100000110000101100011011010110010100
0001001110100100000101010001001110010110000100100011000010111001001100111011101
1001011011001100010101110100101001001110110010010001100101001111010110001001100
0010111001101100101010111110110001101101111011011100111011001100101011100100111
0100001010000010010001110110010110110011000101011101001011000011000100110110001
0110000110010001010010011101101100101011000110110100001101111001000010111001101
1101000111001001101001011100110111010001110010001010000010010001100101001011000
0100111001100000011000000110000001100000010011100101001001001100010011000100001
0111001101110100011100100110100101110011011101000111001000101000001001000110010
1001011000010011100110001001100010011000100110001001001110010100100111011

(22 wystąpień 0000i 5 wystąpień 1111, stąd 270 bajtów kary)

— roberto06
źródło

2

PHP, 86 bajtów + 370 = 456

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

tworzy ciąg binarny i używa wyrażenia regularnego do wykrywania smug. Dane wyjściowe są 1zgodne z prawdą; pusty na fałsz.

Uruchom z echo '<string>' | php -nR '<code>'.

poprawia

odniesienia wsteczne oszczędzają 100 punktów karnych za 3 bajty. (-97 punktów)

porzucone pomysły

join(array_map(str_split())) kosztuje 31 bajtów i 90 kar
i <?=/ $argv[1]zamiast echo/ $argnkosztuje kolejne 2 + 40.
str_pad(decbin())jest droższy niż sprintf: 7 bajtów i 110 kar.
strtr oszczędza 80 punktów karnych za 13 dodatkowych bajtów, ale odniesienia wsteczne są lepsze.
Grupowanie odnośników wstecznych #(.)\\1{3}oszczędza 3 bajty, ale dodaje 10 kar.
foreach kosztuje 3 + 50.
Zapisywanie nazw zmiennych nie jest możliwe.
buforowanie wyjściowe kosztuje 42 + 120.

— Tytus
źródło

Dodaj §at for(§;dla -9.

— Christoph

2

MATL, 16 bajtów + 60 = 76 bajtów

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

Wypróbuj w MATL Online

— Suever
źródło

2

JavaScript (ES8), 91 bajtów + 430 kar = 521 razem

Spowoduje to wygenerowanie 1dla truei 0dla false.

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

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000010110110010111000101110001011100111001101011101001011100110110101100001011100000010100001100011001111010011111001100011001011100110001101101000011000010111001001000011011011110110010001100101010000010111010000101000001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110000011000010110010001010011011101000110000101110010011101000010100000110011001010110011010100101100001100010010110100110001001010010010100100101110011010100110111101101001011011100010100000100010001000100010100100101001

Spróbuj

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

Rozwiń fragment kodu

— Kudłaty
źródło

padStartnie ma w ES6.

— Neil,

Cholera! Ciągle zapominam o zmianie na ES8 za każdym razem, gdy go używam (to samo z ES7 i Array.includes()) - dzięki, @Neil.

— Kudłaty

1

CJam , 23 bajty

Wykorzystuje pomysł Jonathana Allana do pracy z deltami.

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

Wypróbuj online!

Reprezentacja binarna:

00110001011100010011001000110101
00110110011000100011001001100010
00110010011001010111011100111010
00111010001011010101101101010100
01010100010101000101110100100011
001010010110011100101101

Wyjaśnienie:

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.

— Martin Ender
źródło

1

Pyth, 19 + 12 * 10 = 139

!|}*"0"4.BQ}*"1"4.B

Dwójkowy

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

Wyjaśnienie

!|}*"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

— Uriel
źródło

1

JavaScript, 173 + 89 * 10 = 1063

JavaScript nie jest dobry w konwersji ciągów znaków na binarne, ale pomyślałem, że dam temu wyzwaniu szansę tylko dla zabawy.

Kod:

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}

Dwójkowy:

0110011001110101011011100110001101110100011010010110111101101110001010000110111000101001011110110110001000111101001000100010001000111011011001100110111101110010001010000111011001100001011100100010000001110100001111010011000000111011011101000011110001101110001011100110110001100101011011100110011101110100011010000011101101110100001010110010101100101001011000110011110101011011011011100010111001100011011010000110000101110010010000110110111101100100011001010100000101110100001010000111010000101001001011100111010001101111010100110111010001110010011010010110111001100111001010000011001000101001010111010010110001100011001011100111010101101110011100110110100001101001011001100111010000101000010000010111001001110010011000010111100100101000001110000010110101100011010110110011000001011101001011100110110001100101011011100110011101110100011010000010101100110001001010010010111001101010011011110110100101101110001010000011000000101001001010010010110001100010001010110011110101100011001011100110101001101111011010010110111000101000001000100010001000101001001110110111001001100101011101000111010101110010011011100010000001100010001011100110110101100001011101000110001101101000001010000010111101011011001100010101110101111011001101000010110001111101011111000101101100110000010111010111101100110100001011000111110100101111011001110010100100111111001000010011000100111010001000010011000001111101

Wyjaśnienie:

Utwórz ciąg do pracy z:

b="";

Pętla nad każdym znakiem w ciągu:

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

Utwórz tablicę i przekonwertuj ciąg na binarny za pomocą kodu znakowego:

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

Dodaj wiodące zera do tablicy:

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

Połącz tablicę z powrotem w ciąg:

b+=c.join("")

Zwraca, czy w wyniku binarnym znaleziono ciąg czterech lub więcej 1 lub 0 za pomocą wyrażenia regularnego:

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

Skrzypce:

https://jsfiddle.net/vrtLh97c/

Statystyki:

Długość: 173 bajtów Kara: 890 Razem: 1063

Code Golf jest trudny :)

— StephenRios
źródło

Czy możesz podać binarną reprezentację swojego kodu i udokumentować kary?

— Pavel

Kara wynosi 890, co daje łączny wynik 1063.

— Pavel

Dodano sumy do oryginalnego postu.

— StephenRios

1

Używanie 1-1zamiast 0w kilku miejscach może zaoszczędzić ci trochę wad.

— Poke

1

Pyth, 21 + 2 * 10 = 41

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

Wypróbuj online!

Reprezentacja binarna:

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
źródło

1

Siatkówka, 101 + 1390 = 1491

Kod zawiera znaki niedrukowalne, ale pojawiają się w Chrome, jeśli edytujesz post. -jest \x01-\x7f.

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

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

Wypróbuj online

Ten kod używa tegoord , po czym następuje konwersja do binarnej i prosta kontrola nakładających się sekwencji czterech.

Binarnie:

11000010101101100000101011000010101100010000101001010011010111110110000000001010001001010010100001010011011000001100001010110001000010100111101100110010011000000000101000100100011000000000101001111101010101000011000000110001011000000000000100101101011111110110000001011111011011110000101000101001010011010111001101100000001011100000101000101110001010110000101000100100001010100000101000101011011000000010100000110001001010110010100100000001000010100010010001111011001100010111110100110000000010100011000000110001000010100011000100001010011011010010101101100000010111100010100000111111001000010010111001111011001110000111110100101001000010100011000000001010001100000111101100111000011111010111110011000010101101100000101000001010010011010010011001100000001010000010111000101001000000010111101100110011011111010000101000110000

Kary liczone w tym programie Python .

— mbomb007
źródło

Podaj zrzut heksowy i reprezentację binarną, ponieważ zawiera ona niedrukowalne elementy.

— Pavel

Powiedziałem już, co / gdzie znajdują się niedrukowalne, wraz z udostępnieniem programu, który może wydrukować ciąg binarny (odkomentuj wiersz u dołu).

— mbomb007

W porządku, więc ...

— Pavel

1

Python 2 , 74 (długość) + 130 (kara) = 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

Wyjście odbywa się za pomocą kodu wyjścia; 0 to prawda, 1 to fałsz. Generuje wyjście śmieci do STDOUT i STDERR.

Wypróbuj online!

Zrzut binarny

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

— Dennis
źródło

Odkryłem, że 0jest to bardzo złe do włączenia. Lepiej jest użyć1-1

— Poke

@Poke Właśnie zdałem sobie sprawę z mojego błędu. Wynik nie jest używany, więc nie jestem pewien, dlaczego wybrałem 0.

— Dennis

1

JavaScript (ES6), 87 88 + 390 380 = 477 468 bajtów

s=>1-/(.)\1\1\1/.test(s.replace(/[\S\s]/g,c=>(256+c.charCodeAt()).toString(2).slice(1)))

Binarnie:

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000011100110010111001110010011001010111000001101100011000010110001101100101001010000010111101011011010111000101001101011100011100110101110100101111011001110010110001100011001111010011111000101000001100100011010100110110001010110110001100101110011000110110100001100001011100100100001101101111011001000110010101000001011101000010100000101001001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110011011011000110100101100011011001010010100000110001001010010010100100101001

Ponad połowa kary jest w dół do zera w zachodzenia między bajtów, a nie działa w następujących znaków: =>//pa//=>aCoAo.

Ponieważ /s ( 00101111) płacą karę, próbowałem a) zamiany z testna matchb) zamiany z replacena, mapale wynik zawsze był wyższy. Jednak zauważyłem, że [\S\s]była to poprawa w stosunku do [^]. Edycja: Zaoszczędź 9 bajtów dzięki @Shaggy.

— Neil
źródło

Myślę, że |klasa postaci nie powinna tam być

— ETHproductions

@ETHproductions Poprawnie to wyjaśniłem ...

— Neil

Można golić 10 na swojej kary zastępując !ze 1-w sumie 468. I można dokonać dalszych oszczędności 5 bajtów zastępując [\S\s]ze .w sumie 463.

— Kudłaty

@Shaggy Dzięki, chociaż nie jestem pewien, czy nowe wiersze liczą się jako do wydruku, więc zagram to na razie bezpiecznie.

— Neil,

Czy js obsługuje flagę wielokrotnego wyrażenia regularnego? Jeśli tak, możesz zaakceptować sugestię Kudłatego i dodać flagę, aby nadal zapisywać bajty.

— Pavel

1

Pyth , 16 + 1 x 10 = 26 bajtów

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

Wypróbuj online!

Dwójkowy

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

Wydziwianie

Aby uniknąć wad, należy wykonać następujące zmiany:

Używanie qZ(jest równe zero) zamiast !(negowanie)
Używanie :xy0(wyszukiwanie) zamiast }xy(jest listą podrzędną)
Użycie Z(zmienna, domyślnie zero) zamiast 0(samo zero)

Ulepszenia

Nie znajduję żadnego sposobu na obejście kary. Mamy następujące polecenia związane z plikiem binarnym:

.Bbinarny ( 00101110 01[0000]10)
Ccharcode ( 01[0000]11)
.Ooctary ( 00101110 0100[1111])
.Hszesnastkowy ( 00101110 01001[000)

Należy zauważyć, że .Hrównież daje nam karę, bo każdy ma swój charakter druku binarną reprezentację począwszy 0. Dlatego użyłem najbardziej bezpośredniego, czyli .Bbezpośrednio przekonwertowałem go na binarny.

Mogę zakończyć, .Haby uniknąć kary, ale kosztuje mnie to 27 bajtów ...

Generacja

Znalazłem wszystkie dozwolone znaki, które nie zawierają 0000lub 1111i nie kończą się na 000(ponieważ następny znak musi zaczynać się od 0):

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

Oto postacie, które kończą się 1000. Można ich używać tylko na końcu:

(8HXhx

— Leaky Nun
źródło

Odłącz 4 bity

Przypadki testowe

Zasady

Tabela liderów

Galaretka , 18 bajtów + 0 kar = 18

W jaki sposób?

Java 7, 812 726 673 644 634 616 599 588 145 bajtów + 10 * 44 = 585

Dwójkowy

Stare rozwiązanie przesunięcia bitów 141 bajtów + 10 * 101 = 1,151

Dwójkowy

APL (Dyalog Classic) , 26 + 1 × 10 = 36 bajtów

Notatki

Uległość

Źródło binarne

Wyjaśnienie

Walk-through

Galaretka 28 + 140 demeritów = 168

Wyjaśnienie

Strony kodowe

05AB1E , 22 + 3 * 10 = 52

Perl , 33 + 160 = 193

PHP, 98 + 270 = 368 bajtów

PHP, 86 bajtów + 370 = 456

MATL, 16 bajtów + 60 = 76 bajtów

JavaScript (ES8), 91 bajtów + 430 kar = 521 razem

Spróbuj

CJam , 23 bajty

Pyth, 19 + 12 * 10 = 139

Dwójkowy

Wyjaśnienie

JavaScript, 173 + 89 * 10 = 1063

Kod:

Dwójkowy:

Wyjaśnienie:

Skrzypce:

Statystyki:

Pyth, 21 + 2 * 10 = 41

Siatkówka, 101 + 1390 = 1491

Python 2 , 74 (długość) + 130 (kara) = 204

Zrzut binarny

JavaScript (ES6), 87 88 + 390 380 = 477 468 bajtów

Pyth , 16 + 1 x 10 = 26 bajtów

Dwójkowy

Wydziwianie

Ulepszenia

Generacja