Votre tâche: étant donné une chaîne d'entrée, déterminez si la représentation binaire de cette chaîne n'a pas 4 1s ou 0s d'affilée, n'importe où. En outre, votre code lui-même ne doit pas contenir de telles séries de quatre consécutives.

Cas de test

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

Règles

L'entrée sera toujours dans la plage ASCII imprimable, y compris les caractères d'espacement.
- Votre code peut utiliser n'importe quel encodage, car il n'a d'importance qu'au niveau du bit.
Étant donné que cette condition empêche l'utilisation d'espace blanc et de nombreux autres caractères, votre code peut en fait contenir de telles exécutions de quatre d'affilée, avec une pénalité de 10 octets pour chaque exécution.
- Une course de 5 1s ou 0s compte pour deux courses, 6 consécutives comptent pour trois courses, etc.
L'entrée sera une chaîne ou un tableau de caractères, pas toute autre forme.
Vous pouvez écrire un programme ou une fonction complète.
Vous devez fournir la représentation binaire de votre code dans votre réponse.

Bonne chance, le score le plus bas gagne!

Ce script pourrait vous aider avec votre défi, mettre votre code en entrée et il vous donnera la représentation binaire de votre code, sa longueur, votre pénalité et le score total, si vous utilisez UTF-8.

Classement

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.

Afficher l'extrait de code

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

Développer l'extrait

— Pavel
source

1

Je suis à peu près sûr que l'extrait est bogué, par exemple, je vois la ||liste et c'est le cas 0111110001111100.

— Ørjan Johansen

Bon, bon point. Une seconde.

— Pavel

2

Cela aurait été encore plus amusant si la tâche avait été de trouver le score d'une chaîne.

— Adám

1

@JonathanAllan bien, comme je le voulais, c'est vrai, mais après réflexion, je ne vois pas vraiment de raison à cela, alors je vais le changer.

— Pavel

1

@Pavel La notation n'est pas basée uniquement sur les octets s'il y a des pénalités. Cela en fait un [code-challenge], pas un [code-golf]. Du wiki wiki: "Si la longueur du code source n'est pas le critère de notation principal, envisagez d'utiliser une autre balise à la place." TL; DR, puisque le score réel = / = le nombre d'octets du programme et le code le plus court ne signifie pas obtenir le meilleur score, ce n'est pas [code-golf].

— mbomb007

19

Gelée , 18 octets + 0 pénalité = 18

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

Renvoie 1s'il n'y a pas de chaînes de bits égales de longueur 4 ou plus dans la représentation de mot à 8 bits de l'entrée de chaîne ASCII, et 0sinon.

Essayez-le en ligne! (suite de tests avec des cas supplémentaires ajoutés)

En utilisant la page de codes de Jelly, il n'y a pas de sous-chaînes de longueur 4 ou plus de bits égaux:

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

Avec des longueurs de bits égales:

221323221211111312322133122121221111213121123132213111122211311332313211313211111112

Comment?

Les astuces pour éviter les démérites sont:

pour éviter la « conversion de caractère à ordinal » monade Oen convertissant le nombre 79de caractères à l' aide d' un Ọsuivi d'une « évaluation d' un code Jelly avec entrée », v.
pour éviter la conversion directe en binaire en utilisant B( 0x42, 1000010) par l'alternative simple à deux octets en b2utilisant la conversion de base dyadique générique.
pour éviter quelques choix normaux pour compter les séries de bits égaux - le premier choix serait "toutes les tranches qui se chevauchent de longueur donnée", ṡ( 0xF5ou 11110101). Un deuxième choix pourrait être d'utiliser "toutes les sous-listes", Ẇ( 0xCFou 11001111).
Une solution de contournement que j'ai utilisée avant celle actuelle était de prendre les incréments (entre les éléments consécutifs) avec I(mettre les zéros et les uns sur un pied d'égalité), et de rechercher toute occurrence de trois zéros d'affilée. Pour ce faire, j'ai converti tous les zéros en uns en utilisant la fonction binomiale avec 2cie 2Cx - en faisant le -1s devenir 0s le 1s devenir 2s, et le 0s devenir1s; de cette façon, le code peut rechercher la première occurrence de la sous-liste [1,1,1]avec w111.
Toutefois , un chemin plus court est devenu évident - pour imiter l'action de « toutes les tranches qui se chevauchent d' une longueur donnée », ṡon peut utiliser un 4 -wise se chevauchent à réduire certains dyade, <dyad>4\. Si cela est effectué avec addition, +4\il compte les 1s, donc tout 0ou 4être présent est l'indicateur pour retourner une valeur véridique. La question ici est que la prochaine étape évidente serait de prendre le modulo 4 de cela pour mettre les 0et 4entrées sur un pied d' égalité , tout en laissant les autres valeurs possibles ( 1, 2et 3) sans changement, mais +\%4a\%à l'intérieur, qui a la valeur de bit 010111 0000 100100. Afin d'éviter cette pénalité, les nombres sont tous convertis en base 4 avec b4(mappage 0vers [0], 1vers [1], 2vers [2], 3vers [3]et 4vers [1,0]) et toute la liste est aplatie avec F. Maintenant, le dernier test consiste simplement à vérifier s'il y a des 0s dans la liste, réalisables directement avec la monade Ạ.

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?

Remarque: La raison pour laquelle un 2 est concaténé avec la liste ordinale est de traiter les cas de bord où la seule série de 4 dans la chaîne d'entrée se trouve dans les zéros de tête du tout premier caractère - ces caractères sont: tab; saut de ligne; et retour de transport. Sans cela, la conversion de base 256 supprime efficacement les zéros de tête de la chaîne binaire (entièrement concaténée); avec les 2 premiers, les zéros de tête seront là et un supplémentaire et zéro devant eux. Puisqu'aucun ASCII imprimable n'a exactement trois zéros en tête, il n'est pas nécessaire de supprimer ces bits supplémentaires avant le reste de la vérification.

— Jonathan Allan
source

Je suppose que vous pouvez simplement ajouter une négation ou quelque chose de similaire pour vous conformer à la valeur que vous produisez / renvoyez pour la vérité et la fausseté doit être cohérente, ce que j'interprète comme "la même valeur à chaque fois pour la vérité" et la même pour la fausse. Votre vrai / faux est également opposé à ceux de la question.

— Emigna

Je me suis simplement renseigné à ce sujet - lorsque je l'ai lu à l'origine (il y a plusieurs heures), j'ai pris "La valeur que vous produisez / renvoyez pour la vérité et la fausse doit être cohérente." pour signifier que nous pourrions sortir dans les deux sens tant qu'il restera le même chemin entre les runs ... Une négation directe entraînera un démérite.

— Jonathan Allan

Je pourrais certainement en sauver aussi si je n'ai pas à le faire. Jusqu'à un score très bas avec la nouvelle version sur laquelle je travaille. J'espère que c'est vous qui avez interprété correctement :)

— Emigna

Eh bien, j'ai donné un suffixe de deux octets qui fait l'affaire, donnant à la fois le même chemin que les exemples et des valeurs strictement cohérentes 0et 1si besoin est.

— Jonathan Allan

Agréable. Au plaisir de voir comment vous l'avez fait. Je descends seulement à 15 si

— j'ignore

12

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

J'utilise des sauts de ligne au lieu d'espaces pour essayer de minimiser la pénalité ...

Essayez-le en ligne!

Binaire

01100010011011110110111101101100011001010110000101101110000010100110001000101000011000110110100001100001011100100101101101011101011000100010100101111011010100110111010001110010011010010110111001100111000010100110011100111101001000100010001000111011011001100110111101110010001010000110001101101000011000010111001000001010011000110011101001100010001010010110011100101011001111010110011100101110011001100110111101110010011011010110000101110100001010000010001000100101001000100010101100101000001100010010110100110001001010010010101100100010001110000110010000100010001011000110111001100101011101110000101001001001011011100111010001100101011001110110010101110010001010000100100101101110011101000110010101100111011001010111001000101110011101000110111101010011011101000111001001101001011011100110011100101000011000110010110000110010001010010010100100101001001110110111001001100101011101000111010101110010011011100010000101100111001011100110110101100001011101000110001101101000011001010111001100101000001000100010111000101010001010000010111000101001010111000101110000110001010111000101110000110001010111000101110000110001001011100010101000100010001010010011101101111101

Ancienne solution de décalage de bits 141 octets + 10 * 101 = 1151

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;}

Essayez-le en ligne!

Binaire

011000100110111101101111011011000110010101100001011011100000101001100010001010000110001101101000011000010111001001011011010111010110001000101001011110110000101001101001011011100111010000001010011011110011110100110000001011000111000000111101001100000010110001101001001110110000101001100110011011110111001000101000011000110110100001100001011100100000101001100011001110100110001000101001011110110110011001101111011100100010100001101001001111010011000000111011011010010011110000111000001110110010100101111011011010010110011000101000001010000110001100100110001010000011000100111100001111000110100100101011001010110010100100101001001111000011000100101001011110110110111100111101001100000011101101110000001010110010101100111011011111010110010101101100011100110110010101111011011100000011110100110000001110110110111100101011001010110011101101111101011010010110011000101000001100110011110001101111011111000011001100111100011100000010100101110010011001010111010001110101011100100110111000001010001101100011110000110101001110110111110101111101011100100110010101110100011101010111001001101110000010100011010100111100001101100011101101111101

— Poussée
source

Belle astuce avec les nouvelles lignes. Compter 00000/ 11111comme deux pistes, 000000/ 111111comme trois, etc. Je compte 101 pistes au total.

— ETHproductions

@ETHproductions Fixed

— Poke

Cela devrait juste gagner car Java n'a jamais été fait pour cela

— Christopher

10

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

Remarques

Contient un cycle de 4 de 1. Requiert ⎕IO←0ce qui est par défaut sur de nombreux systèmes. Notez que cela doit être exécuté sur un interpréteur classique afin que les chaînes soient d'un octet par caractère.

Soumission

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

Essayez-le en ligne!

Source binaire

_{^{00110001101011001001110010110010100101110101110010111001001010001101011100110100010111001010100010}} 1111_{^{001011101110101011101010110010100110111010101010001001101100110001001100011000110001000100010100101000110111}}

Explication

⍞ Demander une entrée de chaîne

11 ⎕DR convertir à une -bit booléenne ( 1 ) D ata R ePresentation

⊂ joindre afin que nous puissions lui appliquer plusieurs choses

(… Des ) ⍷¨ indicateurs binaires où commence chacune des séquences suivantes…

× signe (pas d'opération sur les données binaires, mais inclus en tant qu'espaceur pour diviser les exécutions)

4 \¨ développer (copier) chacun à la longueur quatre

⍳ les nombres entiers jusqu'à

≢ le décompte de

⍬⍬ la liste composée de deux listes numériques vides

∊ enrôler (aplatir)

⌈\ maximum cumulatif

⌽ sens inverse

⊃ choisissez le premier

1 ≠ est-ce différent? (c.-à-d. NON)

Procédure pas à pas

Nous allons entrer "48" dans la version non gérée non exécutée ~ ∨/ ∊ (0 0 0 0)(1 1 1 1) ⍷¨ ⊂ 11 ⎕DR ⍞:

11 ⎕DR ⍞ convertit "48" en 0 0 1 1 0 1 0 0 0 0 1 1 1 0 0 0 (c.-à-d. Dec 52 56, Hex 34 38)

(0 0 0 0)(1 1 1 1) ⍷¨ ⊂trouve les débuts des courses 0 et 1; (0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0) (0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)

∨/ ∊regarde s'il y a une vérité (c'est-à-dire des courses); 1

~nie cela; 0

— Adam
source

4

Gelée 28 + 140 démérites = 168

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

Explication

OB

Convertit l'argument en une liste de leurs encodages binaires, par exemple

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

La pièce suivante

UÇ€U

corrige le fait que la liste ci-dessus peut Bne pas contenir de caractères car elle n'inclut pas les zéros de tête Ç€appelle le lien précédemment défini sur chaque élément qui restaure ce

L8_0xṭ

Ce lien équivaut à

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

Par exemple

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

Nous remontons la liste avant et après cette opération (les deux Uappels dans cette liste) pour que ce soit un préfixe plutôt qu'un ajout. La pièce suivante

FŒr

Aplatit la liste ( F), donnant la chaîne binaire totale du codage ASCII, et la longueur d'exécution code la sortie ( Œr). Donc par exemple

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

et

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

Enfin, nous vérifions si chaque élément est <4 (heureusement, cela est toujours vrai pour 0,1) avec

<4F

Par exemple

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]

finalement

Ạ

Renvoie 0 si l'une d'entre elles est fausse (dans ce cas, 0).

Pages de code

Dans la page de codes de Jelly, ce code fait 20 octets mais compte 27 séries de violations de règles. En UTF-8, il est de 28 octets mais avec seulement 14 séries de violations.

— walpen
source

3

05AB1E , 22 + 3 * 10 = 52

Sauvegarde de 2 pénalités en empruntant le delta de la réponse de Jonathan Allan à Jelly

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

Essayez-le en ligne!

Explication

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

Représentation binaire du code

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

Les 3 exécutions de pénalités sont vy¦}utilisées pour couper le premier octet de chaque chaîne binaire, mais c'est toujours moins cher que les 4 exécutions que nous obtiendrions des plus courtes €¦.

— Emigna
source

@JonathanAllan: Je le mentionne un peu à la fin (mais pas en détail), mais malheureusement la représentation binaire de €CP-1252 est celle 10000000qui encourt une pénalité de 4 par elle-même.

— Emigna

Ah, tu le fais! ... et mon code Python pour obtenir la représentation était incorrect comme je l'ai mis # coding: cp1252en haut> _ <

— Jonathan Allan

3

Perl , 33 + 160 = 193

32 octets de code + 1 octet pour l' -nindicateur.

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

(l'entrée doit être fournie sans nouvelle ligne finale. Le lien Essayer en ligne a un -ldrapeau pour supprimer les nouvelles lignes, mais pour une seule entrée, ce n'est pas nécessaire).

Essayez-le en ligne!

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

Quelques notes:

(.)\1\1\1économise quelques pénalités (.)\1{3}, 1111|0{4}ou tout autre regex auquel je pourrais penser (à utiliser 0ou {}à un coût élevé).
printéconomise ~ 8 points par rapport à l'utilisation -pet $_=parce qu'il pcontient une séquence de 4 0alors nque non
+en tant que délimiteur pour l'expression régulière enregistre une exécution de ce 1qui est dans /.
faire deux étapes au lieu d'une avec !~enregistre deux exécutions ( ~est 01111110en binaire).
unpack"B*"est assez cher (4 runs), mais je n'ai pas pu trouver moins cher (les solutions sur base ordseront encore plus chères).

— Dada
source

3

PHP, 98 + 270 = 368 octets

Je voulais adopter une approche différente de celle proposée par Titus , et j'ai terminé avec un programme légèrement plus long, mais moins pénalisé.

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

Sorties 1pour véridique, rien pour falsey.

Essayez-le ici!

Codé en binaire:

0010010001110110001111010111010101101110011100000110000101100011011010110010100
0001001110100100000101010001001110010110000100100011000010111001001100111011101
1001011011001100010101110100101001001110110010010001100101001111010110001001100
0010111001101100101010111110110001101101111011011100111011001100101011100100111
0100001010000010010001110110010110110011000101011101001011000011000100110110001
0110000110010001010010011101101100101011000110110100001101111001000010111001101
1101000111001001101001011100110111010001110010001010000010010001100101001011000
0100111001100000011000000110000001100000010011100101001001001100010011000100001
0111001101110100011100100110100101110011011101000111001000101000001001000110010
1001011000010011100110001001100010011000100110001001001110010100100111011

(22 occurrences de 0000et 5 occurrences de 1111, d'où 270 octets de pénalité)

— roberto06
source

2

PHP, 86 octets + 370 = 456

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

crée la chaîne binaire et utilise une expression régulière pour détecter les stries. La sortie est 1pour la vérité; vide pour falsification.

Courez avec echo '<string>' | php -nR '<code>'.

réglages

les références arrières sauvent 100 pénalités pour 3 octets. (-97 score)

idées abandonnées

join(array_map(str_split())) coûterait 31 octets et 90 pénalités
et <?=/ $argv[1]au lieu de echo/ $argncoûte encore 2 + 40.
str_pad(decbin())est plus coûteux que sprintf: 7 octets et 110 pénalités.
strtr enregistre 80 pénalités pour 13 octets supplémentaires, mais les références arrières sont meilleures.
Le regroupement des références arrière #(.)\\1{3}économise 3 octets, mais ajoute 10 pénalités.
foreach coûte 3 + 50.
Aucune sauvegarde possible sur les noms de variables.
le tampon de sortie coûte 42 + 120.

— Titus
source

Ajoutez un §at for(§;pour -9.

— Christoph

2

MATL, 16 octets + 60 = 76 octets

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

Essayez-le sur MATL Online

— Suever
source

2

JavaScript (ES8), 91 octets + 430 pénalités = 521 au total

Cela sortira 1pour trueet 0pour false.

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

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000010110110010111000101110001011100111001101011101001011100110110101100001011100000010100001100011001111010011111001100011001011100110001101101000011000010111001001000011011011110110010001100101010000010111010000101000001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110000011000010110010001010011011101000110000101110010011101000010100000110011001010110011010100101100001100010010110100110001001010010010100100101110011010100110111101101001011011100010100000100010001000100010100100101001

Essayez-le

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

Développer l'extrait

— Hirsute
source

padStartn'est pas dans ES6.

— Neil

Bon sang! J'oublie toujours de passer à ES8 chaque fois que je l'utilise (idem avec ES7 et Array.includes()) - merci @Neil.

— Shaggy

1

CJam , 23 octets

Utilise l'idée de Jonathan Allan pour travailler avec des deltas.

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

Essayez-le en ligne!

Représentation binaire:

00110001011100010011001000110101
00110110011000100011001001100010
00110010011001010111011100111010
00111010001011010101101101010100
01010100010101000101110100100011
001010010110011100101101

Explication:

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
source

1

Pyth, 19 + 12 * 10 = 139

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

Binaire

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

Explication

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

1

JavaScript, 173 + 89 * 10 = 1063

JavaScript n'est pas bon pour convertir des chaînes en binaire, mais je me suis dit que je tenterais ce défi juste pour le plaisir.

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}

Binaire:

0110011001110101011011100110001101110100011010010110111101101110001010000110111000101001011110110110001000111101001000100010001000111011011001100110111101110010001010000111011001100001011100100010000001110100001111010011000000111011011101000011110001101110001011100110110001100101011011100110011101110100011010000011101101110100001010110010101100101001011000110011110101011011011011100010111001100011011010000110000101110010010000110110111101100100011001010100000101110100001010000111010000101001001011100111010001101111010100110111010001110010011010010110111001100111001010000011001000101001010111010010110001100011001011100111010101101110011100110110100001101001011001100111010000101000010000010111001001110010011000010111100100101000001110000010110101100011010110110011000001011101001011100110110001100101011011100110011101110100011010000010101100110001001010010010111001101010011011110110100101101110001010000011000000101001001010010010110001100010001010110011110101100011001011100110101001101111011010010110111000101000001000100010001000101001001110110111001001100101011101000111010101110010011011100010000001100010001011100110110101100001011101000110001101101000001010000010111101011011001100010101110101111011001101000010110001111101011111000101101100110000010111010111101100110100001011000111110100101111011001110010100100111111001000010011000100111010001000010011000001111101

Explication:

Créez une chaîne avec laquelle travailler:

b="";

Faites une boucle sur chaque caractère de la chaîne:

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

Créez un tableau et convertissez la chaîne en binaire à l'aide du code de caractère:

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

Ajoutez les zéros non significatifs au tableau:

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

Rejoins le tableau dans une chaîne:

b+=c.join("")

Renvoie si une chaîne de quatre ou plusieurs 1 ou 0 a été trouvée dans le résultat binaire en utilisant une expression régulière:

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

Violon:

https://jsfiddle.net/vrtLh97c/

Statistiques:

Longueur: 173 octets Pénalité: 890 Total: 1063

Le golf de code est dur :)

— StephenRios
source

Pouvez-vous fournir la représentation binaire de votre code et documenter les sanctions?

— Pavel

Cela a une pénalité de 890 pour un score total de 1063.

— Pavel

Ajout des totaux au message d'origine.

— StephenRios

1

Utiliser 1-1au lieu de 0dans quelques endroits pourrait vous faire économiser des démérites.

— Poke

1

Pyth, 21 + 2 * 10 = 41

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

Essayez-le en ligne!

Représentation binaire:

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
source

1

Rétine, 101 + 1390 = 1491

Le code contient des caractères non imprimables, mais ils apparaissent dans Chrome si vous modifiez le message. -est \x01-\x7f.

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

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

Essayez-le en ligne

Ce code utilise ceciord , suivi d'une conversion en binaire et d'une simple vérification des séquences de quatre qui se chevauchent.

En binaire:

11000010101101100000101011000010101100010000101001010011010111110110000000001010001001010010100001010011011000001100001010110001000010100111101100110010011000000000101000100100011000000000101001111101010101000011000000110001011000000000000100101101011111110110000001011111011011110000101000101001010011010111001101100000001011100000101000101110001010110000101000100100001010100000101000101011011000000010100000110001001010110010100100000001000010100010010001111011001100010111110100110000000010100011000000110001000010100011000100001010011011010010101101100000010111100010100000111111001000010010111001111011001110000111110100101001000010100011000000001010001100000111101100111000011111010111110011000010101101100000101000001010010011010010011001100000001010000010111000101001000000010111101100110011011111010000101000110000

Pénalités comptées avec ce programme Python .

— mbomb007
source

Veuillez fournir un hexdump et une représentation binaire, car il contient des caractères non imprimables.

— Pavel

J'ai déjà dit ce que / où sont les non imprimables, en plus de fournir un programme qui peut imprimer la chaîne binaire (décommenter la ligne en bas).

— mbomb007

D'accord, alors ..

— Pavel

1

Python 2 , 74 (longueur) + 130 (pénalité) = 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

La sortie se fait via un code de sortie; 0 est vrai, 1 est faux. Produit une sortie poubelle vers STDOUT et STDERR.

Essayez-le en ligne!

Vidage binaire

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
source

J'ai trouvé que 0c'était assez mauvais à inclure. Il vaut mieux utiliser1-1

— Poke

@Poke Je viens de réaliser mon erreur. Le résultat n'est pas utilisé, donc je ne sais pas pourquoi j'ai choisi 0en premier lieu.

— Dennis

1

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

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

En binaire:

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000011100110010111001110010011001010111000001101100011000010110001101100101001010000010111101011011010111000101001101011100011100110101110100101111011001110010110001100011001111010011111000101000001100100011010100110110001010110110001100101110011000110110100001100001011100100100001101101111011001000110010101000001011101000010100000101001001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110011011011000110100101100011011001010010100000110001001010010010100100101001

Plus de la moitié de la pénalité est due à des zéros dans le chevauchement entre octets, plutôt qu'aux exécutions dans les caractères suivants: =>//pa//=>aCoAo .

Comme les /s ( 00101111) paient une pénalité, j'ai essayé a) de passer de testà matchb) de passer de replaceà mapmais le score finissait toujours plus haut. Cependant, j'ai trouvé que [\S\s]c'était une amélioration par rapport à [^]. Edit: Sauvegardé 9 octets au total grâce à @Shaggy.

— Neil
source

Je pense que |dans la classe de personnage n'est pas censé être là

— ETHproductions

@ETHproductions J'ai bien compris mon explication ...

— Neil

Vous pourriez raser 10 de votre pénalité en remplaçant le !par 1-pour un total de 468. Et vous pourriez faire une autre économie de 5 octets en remplaçant [\S\s]par .pour un total de 463.

— Shaggy

@Shaggy Merci, bien que je ne sois pas sûr que les sauts de ligne soient imprimables, je vais donc jouer en toute sécurité pour l'instant.

— Neil

Js prend-il en charge un drapeau d'expression régulière multiligne? Si tel est le cas, vous pouvez accepter la suggestion de Shaggy et ajouter l'indicateur pour enregistrer encore les octets.

— Pavel

1

Pyth , 16 + 1 x 10 = 26 octets

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

Essayez-le en ligne!

Binaire

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

Des trucs

Les alternances suivantes sont effectuées pour éviter les démérites:

Utiliser qZ(est égal à zéro) au lieu de !(nier)
Utiliser :xy0(rechercher) au lieu de }xy(est sous-liste)
Utilisation de Z(variable, par défaut à zéro) au lieu de 0(zéro lui-même)

Améliorations

Je ne trouve aucun moyen de contourner la sanction. Nous avons ces commandes liées au binaire:

.Bbinaire ( 00101110 01[0000]10)
Ccharcode ( 01[0000]11)
.Ooctary ( 00101110 0100[1111])
.Hhexadécimal ( 00101110 01001[000)

Notez que .Hcela nous donnera également une pénalité, car chaque caractère imprimable a sa représentation binaire commençant par 0. Par conséquent, j'ai utilisé le plus direct, qui est de le .Bconvertir directement en binaire.

Je peux finir avec .Hpour éviter la pénalité, mais cela me coûte 27 octets ...

Génération

J'ai trouvé tous les caractères autorisés, qui sont ceux qui ne contiennent pas 0000ou 1111, et qui ne se terminent pas par 000(car le caractère suivant doit commencer par 0):

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

Voici les personnages qui se terminent par 1000. Ils ne peuvent être utilisés qu'à la fin:

(8HXhx

— Leaky Nun
source

Déconnectez 4 bits

Cas de test

Règles

Classement

Gelée , 18 octets + 0 pénalité = 18

Comment?

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

Binaire

Ancienne solution de décalage de bits 141 octets + 10 * 101 = 1151

Binaire

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

Remarques

Soumission

Source binaire

Explication

Procédure pas à pas

Gelée 28 + 140 démérites = 168

Explication

Pages de code

05AB1E , 22 + 3 * 10 = 52

Perl , 33 + 160 = 193

PHP, 98 + 270 = 368 octets

PHP, 86 octets + 370 = 456

MATL, 16 octets + 60 = 76 octets

JavaScript (ES8), 91 octets + 430 pénalités = 521 au total

Essayez-le

CJam , 23 octets

Pyth, 19 + 12 * 10 = 139

Binaire

Explication

JavaScript, 173 + 89 * 10 = 1063

Code:

Binaire:

Explication:

Violon:

Statistiques:

Pyth, 21 + 2 * 10 = 41

Rétine, 101 + 1390 = 1491

Python 2 , 74 (longueur) + 130 (pénalité) = 204

Vidage binaire

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

Pyth , 16 + 1 x 10 = 26 octets

Binaire

Des trucs

Améliorations

Génération