Ihre Aufgabe: Bestimmen Sie bei gegebener Eingabezeichenfolge, ob die Binärdarstellung dieser Zeichenfolge an keiner Stelle 4 1s oder 0s hintereinander enthält. Darüber hinaus sollte Ihr Code selbst keine solchen Reihen von vier aufeinanderfolgenden Zeichen enthalten.

Testfälle

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

Regeln

• Die Eingabe erfolgt immer im druckbaren ASCII-Bereich, einschließlich Leerzeichen.
  • Ihr Code kann eine beliebige Codierung verwenden, da dies nur auf Bitebene von Bedeutung ist.
• Da diese Bedingung die Verwendung von Weißraum und viele anderen Zeichen verhindert, Ihr Code tatsächlich kann solche Läufe von vier in einer Reihe enthält, bei einer 10 - Byte - Strafe für jeden Lauf.
  • Ein Lauf von 5 1s oder 0s zählt als zwei Läufe, 6 in einer Reihe zählt als drei Läufe usw.
• Die Eingabe ist eine Zeichenfolge oder ein Zeichen-Array, keine andere Form.
• Sie können ein komplettes Programm oder eine Funktion schreiben.
• Sie müssen die binäre Darstellung Ihres Codes in Ihrer Antwort angeben.

Viel Glück, die niedrigste Punktzahl gewinnt!

Dieses Skript kann Ihnen bei Ihrer Herausforderung helfen, Ihren Code in die Eingabe einzufügen und gibt Ihnen die Binärdarstellung Ihres Codes, seine Länge, Ihre Strafe und die Gesamtpunktzahl an, wenn Sie UTF-8 verwenden.

Bestenliste

Hier ist ein Stack-Snippet, um sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache zu generieren.

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

Gelee , 18 Bytes + 0 Strafen = 18

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

Gibt zurück, 1ob in der 8-Bit-Wortdarstellung der ASCII-Zeichenfolgeingabe keine gleichen Bitfolgen mit einer Länge von 4 oder mehr vorhanden sind 0.

Probieren Sie es online! (Testsuite mit einigen zusätzlichen Fällen hinzugefügt)

Mit Jellys Codepage gibt es keine 4 oder längeren Teilzeichenfolgen mit gleichen Bits:

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

Bei bitgleichen Lauflängen von:

221323221211111312322133122121221111213121123132213111122211311332313211313211111112

Wie?

Tricks, um Fehler zu vermeiden, sind:

• Um die "Konvertierung von Zeichen in Ordnungszahl" zu vermeiden, Okonvertieren Sie die Zahl 79in ein Zeichen, Ọgefolgt von einer "Bewertung des Jelly - Codes mit Eingabe" v.

• Vermeidung der direkten Umwandlung in eine Binärdatei unter Verwendung von B( 0x42, 1000010) durch die einfache Zwei-Byte-Alternative unter b2Verwendung der generischen dyadischen Basenkonvertierung.

• Um einige normale Auswahlmöglichkeiten für das Zählen der Läufe gleicher Bits zu vermeiden, wäre die erste Wahl "alle überlappenden Schichten mit gegebener Länge" ṡ( 0xF5oder 11110101). Eine zweite Möglichkeit könnte darin bestehen, "alle Unterlisten" Ẇ( 0xCFoder 11001111) zu verwenden.
  Eine Problemumgehung, die ich vor der aktuellen verwendet habe, bestand darin, die Inkremente (zwischen aufeinanderfolgenden Elementen) mit I(Nullen und Einsen auf die gleiche Basis stellen) zu setzen und nach jedem Auftreten von drei Nullen in einer Reihe zu suchen. Zu tun , dass ich alle Nullen zu Einsen durch die Verwendung der binomischen Funktion mit umgerechnet 2calso 2Cx - Herstellung der -1s geworden 0s die 1s werden 2s, und die 0s werden1s; Auf diese Weise kann der Code nach dem ersten Vorkommen der Unterliste [1,1,1]mit suchen w111.
  Es zeigte sich jedoch ein kürzerer Weg - um die Wirkung von "allen überlappenden Scheiben gegebener Länge" nachzuahmen ṡ, kann man mit einer Dyade eine 4- fach überlappende Reduktion verwenden <dyad>4\. Wenn dies mit der Zugabe durchgeführt wird, +4\zählt es die 1s, so ist, dann jedes 0oder 4vorhanden ist der Indikator einen truthy Wert zurückzukehren. Das Problem hierbei ist , dass der nächste offensichtliche Schritt der Modulo zu nehmen wäre 4 davon die setzen 0und 4Einträge auf gleiche Ebene , während die anderen möglichen Werte (Abfahrt 1, 2und 3) unverändert, aber +\%4hat\%inside, der den Bitwert 010111 0000 100100 hat. Um diese Strafe zu vermeiden, werden alle Zahlen mit (Mapping auf , auf , auf , auf und auf ) zur Basis 4 konvertiert und die gesamte Liste wird mit abgeflacht . Jetzt ist der letzte Test einfach zu überprüfen, ob es irgendwelche s in der Liste gibt, die direkt mit der Monade erreichbar sind .b40[0]1[1]2[2]3[3]4[1,0]F0Ạ

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?

Hinweis: Der Grund, warum eine 2 mit der Ordnungsliste verknüpft ist, liegt darin, dass die Kantenfälle behandelt werden, in denen sich der einzige 4er- Lauf in der Eingabezeichenfolge in den führenden Nullen des allerersten Zeichens befindet. Diese Zeichen sind: tab; Zeilenvorschub; und Wagenrücklauf. Ohne dies entfernt die Basis-256-Konvertierung effektiv führende Nullen aus der (vollständig verketteten) Binärzeichenfolge; mit der führenden 2 werden die führenden Nullen da sein und eine zusätzliche Eins und Null vor ihnen. Da kein druckbares ASCII genau drei führende Nullen hat, müssen diese zusätzlichen Bits vor dem Rest der Prüfung nicht verworfen werden.

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

Ich benutze Zeilenumbrüche anstelle von Leerzeichen, um die Strafe so gering wie möglich zu halten ...

Probieren Sie es online!

Binär

01100010011011110110111101101100011001010110000101101110000010100110001000101000011000110110100001100001011100100101101101011101011000100010100101111011010100110111010001110010011010010110111001100111000010100110011100111101001000100010001000111011011001100110111101110010001010000110001101101000011000010111001000001010011000110011101001100010001010010110011100101011001111010110011100101110011001100110111101110010011011010110000101110100001010000010001000100101001000100010101100101000001100010010110100110001001010010010101100100010001110000110010000100010001011000110111001100101011101110000101001001001011011100111010001100101011001110110010101110010001010000100100101101110011101000110010101100111011001010111001000101110011101000110111101010011011101000111001001101001011011100110011100101000011000110010110000110010001010010010100100101001001110110111001001100101011101000111010101110010011011100010000101100111001011100110110101100001011101000110001101101000011001010111001100101000001000100010111000101010001010000010111000101001010111000101110000110001010111000101110000110001010111000101110000110001001011100010101000100010001010010011101101111101

Alte Bitverschiebungslösung 141 Bytes + 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;}

Probieren Sie es online!

Binär

011000100110111101101111011011000110010101100001011011100000101001100010001010000110001101101000011000010111001001011011010111010110001000101001011110110000101001101001011011100111010000001010011011110011110100110000001011000111000000111101001100000010110001101001001110110000101001100110011011110111001000101000011000110110100001100001011100100000101001100011001110100110001000101001011110110110011001101111011100100010100001101001001111010011000000111011011010010011110000111000001110110010100101111011011010010110011000101000001010000110001100100110001010000011000100111100001111000110100100101011001010110010100100101001001111000011000100101001011110110110111100111101001100000011101101110000001010110010101100111011011111010110010101101100011100110110010101111011011100000011110100110000001110110110111100101011001010110011101101111101011010010110011000101000001100110011110001101111011111000011001100111100011100000010100101110010011001010111010001110101011100100110111000001010001101100011110000110101001110110111110101111101011100100110010101110100011101010111001001101110000010100011010100111100001101100011101101111101

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

Anmerkungen

Enthält einen 4-Run von 1s. Benötigt, ⎕IO←0was auf vielen Systemen Standard ist. Beachten Sie, dass dies muss auf einem klassischen Interpreter ausgeführt werden , so dass Strings ein Byte pro Zeichen sind.

Einreichung

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

Probieren Sie es online!

Binäre Quelle

_{^{001100011010110010011100101100101001011101011100101110010010100011010111010100010111001010100010}} 1111 _{^{00101110111010101110101011001010111010101010100011000100010001100011000}}

Erläuterung

⍞ Eingabeaufforderung für Zeichenfolge

11 ⎕DR umwandeln 1 -Bit Boolean ( 1 ) D ata R ePresentation

⊂ umschließen, damit wir mehrere Dinge darauf anwenden können

(… ) ⍷¨ Binäre Indikatoren, bei denen jede der folgenden Sequenzen beginnt…

 × sign (no-op für binäre Daten, aber als Spacer zum Teilen von Läufen enthalten)

 4 \¨ erweitere (kopiere) jedes auf die Länge vier

 ⍳ die ganzen Zahlen bis zu

 ≢ die Bilanz von

 ⍬⍬  Die Liste besteht aus zwei leeren numerischen Listen

∊ eintreten (abflachen)

⌈\ kumulatives Maximum

⌽ umkehren

⊃ wähle den ersten aus

1 ≠ unterscheidet man sich von? (dh NICHT)

Begehbar

Wir werden "48" in die ungolfed un-de-runed Version eingeben ~ ∨/ ∊ (0 0 0 0)(1 1 1 1) ⍷¨ ⊂ 11 ⎕DR ⍞:

11 ⎕DR ⍞ konvertiert "48" in 0 0 1 1 0 1 0 0 0 0 1 1 1 0 0 0 (dh Dec 52 56, Hex 34 38)

(0 0 0 0)(1 1 1 1) ⍷¨ ⊂findet Anfänge von 0-Runs und 1-Runs; (0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0) (0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)

∨/ ∊prüft, ob es eine Wahrheit gibt (dh irgendwelche Läufe); 1

~negiert das; 0

Jelly 28 + 140 Fehler = 168

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

Erläuterung

OB

Konvertiert das Argument in eine Liste ihrer Binärkodierungen, z

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

Das nächste Stück

UÇ€U

behebt die Tatsache, dass in der obigen Liste Zeichen fehlen können, da Bführende Nullen nicht enthalten sind. Ç€ruft die zuvor definierte Verknüpfung über jedem Element auf, wodurch diese wiederhergestellt wird

L8_0xṭ

Dieser Link ist äquivalent zu

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

Beispielsweise

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

Wir aktualisieren die Liste vor und nach dieser Operation (die beiden UAufrufe in dieser Liste), um zu erreichen, dass dies eher ein Präpend als ein Append ist. Das nächste Stück

FŒr

Reduziert die Liste ( F) und gibt die gesamte Binärzeichenfolge der ASCII-Codierung an. Die Lauflänge codiert die Ausgabe ( Œr). Also zum Beispiel

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

und

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

Abschließend prüfen wir, ob jedes Element <4 ist (zum Glück gilt dies immer für 0,1) mit

<4F

Beispielsweise

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]

Endlich

Ạ

Gibt 0 zurück, wenn eine dieser Angaben falsch ist (in diesem Fall 0).

Codeseiten

In Jellys Codepage ist dieser Code 20 Byte groß, weist jedoch Regelverletzungen im Wert von 27 Läufen auf. In UTF-8 sind es 28 Bytes, aber mit nur 14 Durchläufen sind Verstöße möglich.

05AB1E , 22 + 3 * 10 = 52

2 Elfmeter geliehen und den Delta- Trick von Jonathan Allans Gelee-Antwort entfernt

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

Probieren Sie es online!

Erläuterung

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

Binäre Darstellung des Codes

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

Die 3 Strafläufe stammen von vy¦}denen verwendet wird, um das erste Byte in jeder Binärzeichenfolge abzuschneiden, aber es ist immer noch billiger als die 4 Läufe, die wir von den kürzeren bekommen würden €¦.

Perl , 33 + 160 = 193

32 Byte Code + 1 Byte für -nFlag.

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

(Die Eingabe muss ohne abschließenden Zeilenumbruch erfolgen. Der Link " Online testen" hat das -lFlag zum Entfernen von Zeilenumbrüchen aktiviert, für eine einzelne Eingabe ist dies jedoch nicht erforderlich.)

Probieren Sie es online!

xxd dump:

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

Ein paar Anmerkungen:

• (.)\1\1\1spart ein paar Strafen über (.)\1{3}, 1111|0{4}oder jede andere Regex ich denken konnte (mit 0oder {}kommt zu einem hohen Preis).
• printspart ~ 8 Punkte über Verwendung -pund $_=da penthält einen Lauf von 4 , 0während ndies nicht tut.
• +als Begrenzer für die Regex spart man einen Lauf davon 1ein /.
• macht zwei Schritte statt einem mit !~spart zwei Läufen ( ~ist 01111110in binär).
• unpack"B*"ist ziemlich teuer (4 Läufe), aber ich konnte nicht billiger finden (Lösungen basierend auf ordwird noch teurer sein).

PHP, 98 + 270 = 368 Bytes

Ich wollte einen anderen Ansatz verfolgen als Titus und endete mit einem etwas längeren, aber weniger belasteten Programm.

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

Outputs 1für Wahres, nichts für Falsches.

Probieren Sie es hier aus!

Binär codiert:

0010010001110110001111010111010101101110011100000110000101100011011010110010100
0001001110100100000101010001001110010110000100100011000010111001001100111011101
1001011011001100010101110100101001001110110010010001100101001111010110001001100
0010111001101100101010111110110001101101111011011100111011001100101011100100111
0100001010000010010001110110010110110011000101011101001011000011000100110110001
0110000110010001010010011101101100101011000110110100001101111001000010111001101
1101000111001001101001011100110111010001110010001010000010010001100101001011000
0100111001100000011000000110000001100000010011100101001001001100010011000100001
0111001101110100011100100110100101110011011101000111001000101000001001000110010
1001011000010011100110001001100010011000100110001001001110010100100111011

(22 Vorkommen von 0000und 5 Vorkommen von 1111, daher 270 Bytes Strafe)

PHP, 86 Bytes + 370 = 456

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

Erstellt die Binärzeichenfolge und verwendet einen regulären Ausdruck, um Streifen zu erkennen. Die Ausgabe ist 1für die Wahrheit; leer für falsch.

Laufen Sie mit echo '<string>' | php -nR '<code>'.

Optimierungen

• Rückverweise sparen 100 Strafpunkte für 3 Bytes. (-97 Punkte)

aufgegebene Ideen

• join(array_map(str_split())) würde 31 Bytes und 90 Strafe kosten
• und <?=/ $argv[1]anstelle von echo/ $argnweitere 2 + 40 kosten.
• str_pad(decbin())ist teurer als sprintf: 7 Bytes und 110 Penalty.
• strtr spart 80 Strafpunkte für 13 zusätzliche Bytes, aber Rückverweise sind besser.
• Durch das Gruppieren der Rückverweise werden #(.)\\1{3}3 Bytes gespart, aber 10 Strafpunkte hinzugefügt .
• foreach kostet 3 + 50.
• Kein Speichern der Variablennamen möglich.
• Die Ausgabepufferung kostet 42 + 120.

MATL, 16 Bytes + 60 = 76 Bytes

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

Probieren Sie es bei MATL Online aus

JavaScript (ES8), 91 Bytes + 430 Strafe = 521 insgesamt

Dies wird 1für trueund 0für ausgegeben false.

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

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000010110110010111000101110001011100111001101011101001011100110110101100001011100000010100001100011001111010011111001100011001011100110001101101000011000010111001001000011011011110110010001100101010000010111010000101000001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110000011000010110010001010011011101000110000101110010011101000010100000110011001010110011010100101100001100010010110100110001001010010010100100101110011010100110111101101001011011100010100000100010001000100010100100101001

Versuch es

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 Bytes

Verwendet Jonathan Allans Idee , mit Deltas zu arbeiten.

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

Probieren Sie es online!

Binäre Darstellung:

00110001011100010011001000110101
00110110011000100011001001100010
00110010011001010111011100111010
00111010001011010101101101010100
01010100010101000101110100100011
001010010110011100101101

Erläuterung:

1     e# Push a 1 for (much) later, because we can't use ! for logical NOT.
q     e# Read input.
256b  e# Treat characters as base 256 digits.
2b    e# Convert to binary. The last two steps together give us a flat binary
      e# representation of the input, avoiding both :~ and e_ for flattening.
2ew   e# Get all pairs of consecutive bits.
::-   e# Compute their differences.
[TTT] e# Push [0 0 0].
#     e# Find its index in the list of differences, or -1 if not found.
)g    e# Increment and take signum. We've now got the result we want but 
      e# with the wrong truth value.
-     e# Subtract it from the 1 we pushed earlier to negate the truth value.

Pyth, 19 + 12 · 10 = 139

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

Binär

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

Erläuterung

!|}*"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 ist nicht gut darin, Zeichenfolgen in Binärdateien umzuwandeln, aber ich dachte, ich würde diese Herausforderung nur zum Spaß ausprobieren.

Code:

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}

Binär:

0110011001110101011011100110001101110100011010010110111101101110001010000110111000101001011110110110001000111101001000100010001000111011011001100110111101110010001010000111011001100001011100100010000001110100001111010011000000111011011101000011110001101110001011100110110001100101011011100110011101110100011010000011101101110100001010110010101100101001011000110011110101011011011011100010111001100011011010000110000101110010010000110110111101100100011001010100000101110100001010000111010000101001001011100111010001101111010100110111010001110010011010010110111001100111001010000011001000101001010111010010110001100011001011100111010101101110011100110110100001101001011001100111010000101000010000010111001001110010011000010111100100101000001110000010110101100011010110110011000001011101001011100110110001100101011011100110011101110100011010000010101100110001001010010010111001101010011011110110100101101110001010000011000000101001001010010010110001100010001010110011110101100011001011100110101001101111011010010110111000101000001000100010001000101001001110110111001001100101011101000111010101110010011011100010000001100010001011100110110101100001011101000110001101101000001010000010111101011011001100010101110101111011001101000010110001111101011111000101101100110000010111010111101100110100001011000111110100101111011001110010100100111111001000010011000100111010001000010011000001111101

Erläuterung:

Erstellen Sie eine Zeichenfolge, mit der Sie arbeiten möchten:

b="";

Schleife über jedes Zeichen in der Zeichenkette:

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

Erstellen Sie ein Array und konvertieren Sie die Zeichenfolge mit dem folgenden Zeichencode in eine Binärdatei:

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

Fügen Sie dem Array die führenden Nullen hinzu:

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

Fügen Sie das Array wieder zu einer Zeichenfolge zusammen:

b+=c.join("")

Gibt mit einem regulären Ausdruck zurück, ob eine Zeichenfolge aus vier oder mehr Einsen oder Nullen im binären Ergebnis gefunden wurde:

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

Geige:

https://jsfiddle.net/vrtLh97c/

Statistiken:

Länge: 173 Bytes Strafe: 890 Gesamt: 1063

Code Golf ist schwer :)

Pyth, 21 + 2 · 10 = 41

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

Probieren Sie es online!

Binäre Darstellung:

01001010 00101101 010101[00 00]110010 00101101 00110100 01100101 01010011
00100101 00110010 00101110 01101110 01110010 00101110 01011011 01100100
01001010 00101110 01[0000]10 01110111 01001010

Retina, 101 + 1390 = 1491

Der Code enthält nicht druckbare Zeichen, die jedoch in Chrome angezeigt werden, wenn Sie den Beitrag bearbeiten. -ist \x01-\x7f.

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

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

Probieren Sie es online aus

Dieser Code verwendet diesord , gefolgt von der Konvertierung in eine Binärdatei und einer einfachen Überprüfung auf überlappende Sequenzen von vier.

In binärer Form:

11000010101101100000101011000010101100010000101001010011010111110110000000001010001001010010100001010011011000001100001010110001000010100111101100110010011000000000101000100100011000000000101001111101010101000011000000110001011000000000000100101101011111110110000001011111011011110000101000101001010011010111001101100000001011100000101000101110001010110000101000100100001010100000101000101011011000000010100000110001001010110010100100000001000010100010010001111011001100010111110100110000000010100011000000110001000010100011000100001010011011010010101101100000010111100010100000111111001000010010111001111011001110000111110100101001000010100011000000001010001100000111101100111000011111010111110011000010101101100000101000001010010011010010011001100000001010000010111000101001000000010111101100110011011111010000101000110000

Mit diesem Python-Programm gezählte Strafen .

Python 2 , 74 (Länge) + 130 (Strafe) = 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

Die Ausgabe erfolgt über den Exit-Code. 0 ist wahr, 1 ist falsch. Erzeugt eine Müllausgabe an STDOUT und STDERR.

Probieren Sie es online!

Binärdump

00000000: 01101011 00101100 01101110 00111101 00110010 00101010  k,n=2*
00000006: 01011011 00110001 01011101 00001010 01100110 01101111  [1].fo
0000000c: 01110010 01011011 01100011 01011101 01101001 01101110  r[c]in
00000012: 00101000 01101001 01101110 01110000 01110101 01110100  (input
00000018: 00101000 01101110 00101001 00101010 00110010 00101010  (n)*2*
0000001e: 00110010 00101010 00110010 00101001 01011011 00111010  2*2)[:
00000024: 00110001 00111010 00101101 00110001 01011101 00111010  1:-1]:
0000002a: 01101110 00101100 01101011 00111101 01101011 00101010  n,k=k*
00000030: 01101111 01110010 01100100 00101000 01100011 01011011  ord(c[
00000036: 00111010 01101110 00100101 00110001 00110110 00100101  :n%16%
0000003c: 00110001 00110101 01011101 00101001 00101011 01101110  15])+n
00000042: 00101111 00110010 00101100 01101011 00101010 00110001  /2,k*1
00000048: 00110010 00111000                                      28

JavaScript (ES6), 87 88 + 390 380 = 477 468 Byte

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

In binärer Form:

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000011100110010111001110010011001010111000001101100011000010110001101100101001010000010111101011011010111000101001101011100011100110101110100101111011001110010110001100011001111010011111000101000001100100011010100110110001010110110001100101110011000110110100001100001011100100100001101101111011001000110010101000001011101000010100000101001001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110011011011000110100101100011011001010010100000110001001010010010100100101001

Mehr als die Hälfte der Strafe ist zu Nullen in der Überlappung nach unten zwischen dem Bytes, anstatt den Läufen in den folgenden Zeichen: =>//pa//=>aCoAo.

Da die /s ( 00101111) eine Strafe zahlen, habe ich versucht, a) von testzu wechseln , matchb) von replacezu zu wechseln , mapaber die Punktzahl war immer höher. Allerdings habe ich festgestellt, dass dies [\S\s]eine Verbesserung gegenüber war [^]. Bearbeiten: Insgesamt 9 Bytes dank @Shaggy gespeichert.

Pyth , 16 + 1 × 10 = 26 Bytes

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

Probieren Sie es online!

Binär

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

Tricks

Die folgenden Änderungen werden vorgenommen, um die Nachteile zu vermeiden:

• Verwenden von qZ(ist gleich Null) anstelle von! (negieren)
• Verwenden von :xy0(Suchen nach) anstelle von}xy (ist Unterliste)
• Verwenden von Z(Variable, Standard auf Null) anstelle von 0(Null selbst)

Verbesserungen

Ich finde keine Möglichkeit, die Strafe zu umgehen. Wir haben diese Befehle im Zusammenhang mit binären:

• .Bbinär ( 00101110 01[0000]10)
• Ccharcode ( 01[0000]11)
• .OOktar ( 00101110 0100[1111])
• .Hhexadezimal ( 00101110 01001[000)

Beachten Sie, dass dies .Hebenfalls zu einer Strafe führt, da jedes druckbare Zeichen eine Binärdarstellung hat, die mit beginnt 0. Daher habe ich die direkteste verwendet, nämlich.B direkte Konvertierung in eine Binärdatei.

Ich kann damit enden .H, um die Strafe zu vermeiden, aber es kostet mich 27 Bytes ...

Generation

Ich habe alle erlaubten Zeichen gefunden, die keine 0000oder enthalten 1111und nicht mit enden 000(weil das nächste Zeichen mit beginnen muss 0):

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

Hier sind die Zeichen, die mit enden 1000. Sie können nur am Ende verwendet werden:

• (8HXhx