Sua tarefa: dada uma sequência de entrada, determine se a representação binária dessa sequência não possui 4 1s ou 0s em uma linha, em qualquer lugar. Além disso, seu próprio código não deve conter nenhuma dessas execuções de quatro em uma linha.

Casos de teste

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

Regras

• A entrada sempre estará dentro do intervalo de ASCII imprimível, incluindo caracteres de espaço em branco.
  • Seu código pode usar qualquer codificação, pois isso importa apenas no nível de bits.
• Como essa condição impede o uso de espaço em branco e muitos outros caracteres, o código pode conter quatro execuções consecutivas, com uma penalidade de 10 bytes para cada execução.
  • Uma corrida de 5 1s ou 0s conta como duas corridas, 6 seguidas conta como três corridas, etc.
• A entrada será uma matriz de caracteres ou de caracteres, e não qualquer outra forma.
• Você pode escrever um programa ou função completa.
• Você deve fornecer a representação binária do seu código na sua resposta.

Boa sorte, menor pontuação ganha!

Esse script pode ajudá-lo com seu desafio, colocar seu código na entrada e fornecerá a representação binária do seu código, seu comprimento, sua penalidade e a pontuação total, se você estiver usando UTF-8.

Entre os melhores

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

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

Geléia , 18 bytes + 0 de penalidade = 18

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

Retorna 1se não houver cadeias de bits iguais de comprimento 4 ou mais na representação de palavras de 8 bits da entrada de cadeia ASCII, e 0caso contrário.

Experimente online! (suíte de testes com alguns casos extras adicionados)

Usando a página de código de Jelly, não existem substrings de comprimento igual ou superior a 4 bits iguais:

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

Com comprimentos de execução com bits iguais de:

221323221211111312322133122121221111213121123132213111122211311332313211313211111112

Quão?

Os truques para evitar deméritos são:

• para evitar a mônada "converter de caractere em ordinal" Oconvertendo o número 79em um caractere usando Ọseguido de uma "avaliação do código Jelly com entrada" v,.

• para evitar a conversão direta em binário usando B( 0x42, 1000010) pela alternativa simples de dois bytes b2usando a conversão de base diádica genérica.

• para evitar algumas opções normais para contar as execuções de bits iguais - a primeira opção seria "todas as fatias sobrepostas de determinado comprimento", ṡ( 0xF5ou 11110101). Uma segunda opção pode ser utilizar "todos os sublistas", Ẇ( 0xCFou 11001111).
  Uma solução alternativa que usei antes da atual era fazer os incrementos (entre elementos consecutivos) com I(colocando zeros e uns em pé de igualdade) e procurar qualquer ocorrência de três zeros em uma linha. Para fazer isso eu converti todos os zeros para os de uso da função binomial com 2cisto 2CX - tornando o -1s Torne- 0s as 1s tornar-se 2s, e os 0s tornar-se1s; Dessa forma, o código pode procurar a primeira ocorrência da sublist [1,1,1]com w111.
  No entanto, um caminho mais curto se tornou aparente - para imitar a ação de "todas as fatias sobrepostas de um determinado comprimento", ṡpode-se usar uma redução sobreposta em quatro direções com alguma díade <dyad>4\,. Se isso é realizado com adição, +4\conta os 1s; portanto, qualquer um 0ou 4estar presente é o indicador para retornar um valor verdadeiro. A questão aqui é que o próximo passo óbvio seria a de tomar o módulo 4 do que para colocar as 0e 4entradas em pé de igualdade, deixando os outros valores possíveis ( 1, 2e 3) inalteradas, mas +\%4tem\%dentro, que tem pouco valor 010,111 mil 0000 100100. A fim de evitar que os números penalidade todos são convertidos para a base 4 com b4(mapeamento 0para [0], 1a [1], 2a [2], 3a [3], e 4a [1,0]) e toda a lista é achatado com F. Agora, o último teste é simplesmente verificar se há algum 0s na lista, alcançável diretamente com a mônada Ạ.

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?

Nota: O motivo pelo qual um 2 é concatenado com a lista ordinal é lidar com os casos de borda em que a única execução de 4 na sequência de entrada está nos zeros à esquerda do primeiro caractere - esses caracteres são: tab; alimentação de linha; e retorno de carro. Sem isso, a conversão da base 256 remove efetivamente os zeros à esquerda da sequência binária (totalmente concatenada); com os 2 iniciais, os zeros iniciais estarão lá e um extra e zero antes deles. Como nenhum ASCII imprimível possui exatamente três zeros à esquerda, não é necessário descartar esses bits extras antes do resto da verificação.

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.*");}

Estou usando novas linhas em vez de espaços para tentar minimizar a penalidade ...

Experimente online!

Binário

01100010011011110110111101101100011001010110000101101110000010100110001000101000011000110110100001100001011100100101101101011101011000100010100101111011010100110111010001110010011010010110111001100111000010100110011100111101001000100010001000111011011001100110111101110010001010000110001101101000011000010111001000001010011000110011101001100010001010010110011100101011001111010110011100101110011001100110111101110010011011010110000101110100001010000010001000100101001000100010101100101000001100010010110100110001001010010010101100100010001110000110010000100010001011000110111001100101011101110000101001001001011011100111010001100101011001110110010101110010001010000100100101101110011101000110010101100111011001010111001000101110011101000110111101010011011101000111001001101001011011100110011100101000011000110010110000110010001010010010100100101001001110110111001001100101011101000111010101110010011011100010000101100111001011100110110101100001011101000110001101101000011001010111001100101000001000100010111000101010001010000010111000101001010111000101110000110001010111000101110000110001010111000101110000110001001011100010101000100010001010010011101101111101

Solução antiga de deslocamento de bits 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;}

Experimente online!

Binário

011000100110111101101111011011000110010101100001011011100000101001100010001010000110001101101000011000010111001001011011010111010110001000101001011110110000101001101001011011100111010000001010011011110011110100110000001011000111000000111101001100000010110001101001001110110000101001100110011011110111001000101000011000110110100001100001011100100000101001100011001110100110001000101001011110110110011001101111011100100010100001101001001111010011000000111011011010010011110000111000001110110010100101111011011010010110011000101000001010000110001100100110001010000011000100111100001111000110100100101011001010110010100100101001001111000011000100101001011110110110111100111101001100000011101101110000001010110010101100111011011111010110010101101100011100110110010101111011011100000011110100110000001110110110111100101011001010110011101101111101011010010110011000101000001100110011110001101111011111000011001100111100011100000010100101110010011001010111010001110101011100100110111000001010001101100011110000110101001110110111110101111101011100100110010101110100011101010111001001101110000010100011010100111100001101100011101101111101

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

Notas

Contém um 4-run de 1s. Requer ⎕IO←0qual é o padrão em muitos sistemas. Observe que isso deve ser executado em um intérprete Classic para que as strings tenham um byte por caractere.

Submissão

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

Experimente online!

Fonte binária

_{^{00110001101011001001110010110010100101110101110010111001001010001101011100110100010111001010100010}} 1111 _{^{00101110111010101110101011001010011011101010101000100110111011101100110001001100011000110001000100010000}}

Explicação

⍞ Solicitar entrada de sequência

11 ⎕DR converter para 1- bit Boolean ( 1 ) D ata R ePresentation

⊂ anexar para que possamos aplicar várias coisas a ele

(… ) ⍷¨ Indicadores binários em que cada uma das seguintes seqüências começa…

 × sinal (sem opção em dados binários, mas incluído como espaçador para separar execuções)

 4 \¨ expandir (copiar) cada um para o comprimento quatro

 ⍳ os inteiros até

 ≢ a contagem de

 ⍬⍬  a lista que consiste em duas listas numéricas vazias

∊ alistar-se (achatar)

⌈\ máximo cumulativo

⌽ marcha ré

⊃ escolha o primeiro

1 ≠ é diferente de? (ie NÃO)

Walk-through

Introduziremos "48" na versão não-run-rungolf ~ ∨/ ∊ (0 0 0 0)(1 1 1 1) ⍷¨ ⊂ 11 ⎕DR ⍞:

11 ⎕DR ⍞ converte "48" em 0 0 1 1 0 1 0 0 0 0 1 1 1 0 0 0 (ie 52 de dezembro de 56, hex 34 38)

(0 0 0 0)(1 1 1 1) ⍷¨ ⊂localiza o início de 0 e 1 execuções; (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)

∨/ ∊verifica se existe alguma verdade (ou seja, qualquer execução); 1

~nega isso; 0 0

Gelatina 28 + 140 deméritos = 168

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

Explicação

OB

Converte o argumento em uma lista de suas codificações binárias, por exemplo

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

A próxima peça

UÇ€U

corrige o fato de que a lista acima pode estar faltando caracteres, pois Bnão inclui zeros à esquerda. Ç€chama o link definido anteriormente sobre cada elemento que restaura esse

L8_0xṭ

Este link é equivalente a

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

Por exemplo

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

Nós alteramos a lista antes e depois desta operação (as duas Uchamadas nessa lista) para que isso seja um prefixo em vez de um acréscimo. A próxima peça

FŒr

Nivela a lista ( F), fornecendo a cadeia binária total da codificação ASCII e o comprimento da execução codifica a saída ( Œr). Então por exemplo

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

e

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

Finalmente, verificamos se cada elemento é <4 (felizmente, isso sempre é verdade para 0,1) com

<4F

Por exemplo

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]

Finalmente

Ạ

Retorna 0 se algum deles for falso (neste caso, 0).

Páginas de código

Na página de código do Jelly, esse código tem 20 bytes, mas possui 27 execuções no valor de violações de regras. No UTF-8, são 28 bytes, mas com apenas 14 execuções no valor de violações.

05AB1E , 22 + 3 * 10 = 52

Salva 2 corridas de penalidade emprestando o truque delta da resposta de Jonathan Allan Jelly

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

Experimente online!

Explicação

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

Representação binária do código

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

As 3 corridas de penalidade vy¦}são usadas para cortar o primeiro byte em cada sequência de caracteres binária, mas ainda é mais barato que as 4 corridas que obteríamos das mais curtas €¦.

Perl , 33 + 160 = 193

32 bytes de código + 1 byte para -nsinalizador.

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

(a entrada precisa ser fornecida sem a nova linha final. O link Experimente online tem o -lsinalizador para remover as novas linhas, mas para uma única entrada, não é necessário).

Experimente online!

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

Algumas notas:

• (.)\1\1\1salva algumas penalidades mais (.)\1{3}, 1111|0{4}ou qualquer outro regex que eu poderia pensar (usando 0ou {}tem um custo pesado).
• printeconomiza ~ 8 pontos ao usar -pe $_=porque pcontém uma corrida de 4 0enquanton não.
• +como um delimitador para o regex, salva uma execução 1disso /.
• executar duas etapas em vez de uma com !~salva duas execuções ( ~está 01111110em binário).
• unpack"B*"é bastante caro (4 execuções), mas não consegui encontrar mais barato (a base de soluções ordserá ainda mais cara).

PHP, 98 + 270 = 368 bytes

Queria adotar uma abordagem diferente da proposta por Titus e terminar com um programa um pouco mais longo, porém menos penalizado.

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

Saídas 1para verdade, nada para falsey.

Experimente aqui!

Codificado em binário:

0010010001110110001111010111010101101110011100000110000101100011011010110010100
0001001110100100000101010001001110010110000100100011000010111001001100111011101
1001011011001100010101110100101001001110110010010001100101001111010110001001100
0010111001101100101010111110110001101101111011011100111011001100101011100100111
0100001010000010010001110110010110110011000101011101001011000011000100110110001
0110000110010001010010011101101100101011000110110100001101111001000010111001101
1101000111001001101001011100110111010001110010001010000010010001100101001011000
0100111001100000011000000110000001100000010011100101001001001100010011000100001
0111001101110100011100100110100101110011011101000111001000101000001001000110010
1001011000010011100110001001100010011000100110001001001110010100100111011

(22 ocorrências 0000e 5 ocorrências 1111, daí 270 bytes de penalidade)

PHP, 86 bytes + 370 = 456

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

cria a cadeia binária e usa uma expressão regular para detectar estrias. A saída é 1para verdade; vazio por falsidade.

Corra com echo '<string>' | php -nR '<code>'.

ajustes

• as referências anteriores economizam 100 de penalidade por 3 bytes. (-97 pontuação)

idéias abandonadas

• join(array_map(str_split())) custaria 31 bytes e 90 de penalidade
• e <?=/ em $argv[1]vez de echo/ $argncustam mais 2 + 40.
• str_pad(decbin())é mais caro que sprintf: 7 bytes e 110 de penalidade.
• strtr economiza 80 de penalidade por 13 bytes extras, mas as referências anteriores são melhores.
• O agrupamento das referências anteriores #(.)\\1{3}economiza 3 bytes, mas adiciona 10 de penalidade.
• foreach custa 3 + 50.
• Não é possível salvar os nomes das variáveis.
• o buffer de saída custa 42 + 120.

MATL, 16 bytes + 60 = 76 bytes

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

Experimente no MATL Online

JavaScript (ES8), 91 bytes + 430 de penalidade = 521 total

Isso produzirá 1para truee 0para false.

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

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000010110110010111000101110001011100111001101011101001011100110110101100001011100000010100001100011001111010011111001100011001011100110001101101000011000010111001001000011011011110110010001100101010000010111010000101000001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110000011000010110010001010011011101000110000101110010011101000010100000110011001010110011010100101100001100010010110100110001001010010010100100101110011010100110111101101001011011100010100000100010001000100010100100101001

Tente

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

Usa a idéia de Jonathan Allan para trabalhar com deltas.

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

Experimente online!

Representação binária:

00110001011100010011001000110101
00110110011000100011001001100010
00110010011001010111011100111010
00111010001011010101101101010100
01010100010101000101110100100011
001010010110011100101101

Explicação:

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.

Pitão, 19 + 12 * 10 = 139

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

Binário

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

Explicação

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

O JavaScript não é bom em converter seqüências de caracteres para binárias, mas eu pensei em dar uma chance a este desafio apenas por diversão.

Código:

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ário:

0110011001110101011011100110001101110100011010010110111101101110001010000110111000101001011110110110001000111101001000100010001000111011011001100110111101110010001010000111011001100001011100100010000001110100001111010011000000111011011101000011110001101110001011100110110001100101011011100110011101110100011010000011101101110100001010110010101100101001011000110011110101011011011011100010111001100011011010000110000101110010010000110110111101100100011001010100000101110100001010000111010000101001001011100111010001101111010100110111010001110010011010010110111001100111001010000011001000101001010111010010110001100011001011100111010101101110011100110110100001101001011001100111010000101000010000010111001001110010011000010111100100101000001110000010110101100011010110110011000001011101001011100110110001100101011011100110011101110100011010000010101100110001001010010010111001101010011011110110100101101110001010000011000000101001001010010010110001100010001010110011110101100011001011100110101001101111011010010110111000101000001000100010001000101001001110110111001001100101011101000111010101110010011011100010000001100010001011100110110101100001011101000110001101101000001010000010111101011011001100010101110101111011001101000010110001111101011111000101101100110000010111010111101100110100001011000111110100101111011001110010100100111111001000010011000100111010001000010011000001111101

Explicação:

Crie uma string para trabalhar:

b="";

Faça um loop sobre cada caractere na sequência:

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

Crie uma matriz e converta a string em binário usando o código de caractere:

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

Adicione os zeros à esquerda na matriz:

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

Associe a matriz novamente a uma sequência:

b+=c.join("")

Retorne se uma sequência de quatro ou mais 1 ou 0 foi encontrada no resultado binário usando uma expressão regular:

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

Violino:

https://jsfiddle.net/vrtLh97c/

Estatísticas:

Comprimento: 173 bytes Pena: 890 Total: 1063

Código Golf é difícil :)

Pitão, 21 + 2 * 10 = 41

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

Experimente online!

Representação binária:

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

O código contém caracteres não imprimíveis, mas eles aparecem no Chrome se você editar a postagem. -é \x01-\x7f.

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

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

Experimente online

Esse código usa issoord , seguido pela conversão para binário e uma verificação simples para seqüências sobrepostas de quatro.

Em binário:

11000010101101100000101011000010101100010000101001010011010111110110000000001010001001010010100001010011011000001100001010110001000010100111101100110010011000000000101000100100011000000000101001111101010101000011000000110001011000000000000100101101011111110110000001011111011011110000101000101001010011010111001101100000001011100000101000101110001010110000101000100100001010100000101000101011011000000010100000110001001010110010100100000001000010100010010001111011001100010111110100110000000010100011000000110001000010100011000100001010011011010010101101100000010111100010100000111111001000010010111001111011001110000111110100101001000010100011000000001010001100000111101100111000011111010111110011000010101101100000101000001010010011010010011001100000001010000010111000101001000000010111101100110011011111010000101000110000

Sanções contadas com este programa Python .

Python 2 , 74 (comprimento) + 130 (penalidade) = 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

A saída é via código de saída; 0 é verdadeiro, 1 é falso. Produz saída de lixo para STDOUT e STDERR.

Experimente online!

Despejo binário

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 bytes

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

Em binário:

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000011100110010111001110010011001010111000001101100011000010110001101100101001010000010111101011011010111000101001101011100011100110101110100101111011001110010110001100011001111010011111000101000001100100011010100110110001010110110001100101110011000110110100001100001011100100100001101101111011001000110010101000001011101000010100000101001001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110011011011000110100101100011011001010010100000110001001010010010100100101001

Mais de metade da pena para baixo é a zeros na sobreposição entre os bytes, em vez das pistas nas seguintes caracteres: =>//pa//=>aCoAo.

Como os /s ( 00101111) pagam uma penalidade, tentei a) alternar de testpara matchb) alternar de replacepara mapmas a pontuação sempre foi mais alta. No entanto, achei que [\S\s]houve uma melhoria [^]. Editar: salvou 9 bytes no geral graças ao @Shaggy.

Pitão , 16 + 1 x 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

Experimente online!

Binário

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

Truques

As seguintes alternâncias são feitas para evitar os deméritos:

• Usando qZ(é igual a zero) em vez de !(negar)
• Usando :xy0(procurar) em vez de }xy(está sublistado)
• Usando Z(variável, padrão como zero) em vez de 0(o próprio zero)

Melhorias

Não encontro nenhuma maneira de contornar a penalidade. Temos estes comandos relacionados ao binário:

• .Bbinário ( 00101110 01[0000]10)
• Ccharcode ( 01[0000]11)
• .Ooctário ( 00101110 0100[1111])
• .Hhexadecimal ( 00101110 01001[000)

Observe que .Htambém nos dará uma penalidade, porque todo caractere imprimível tem sua representação binária começando com 0. Portanto, usei o mais direto, ou seja .B, convertendo-o diretamente em binário.

Posso terminar com .Hpara evitar a penalidade, mas me custa 27 bytes ...

Geração

Encontrei todos os caracteres permitidos, que não contêm 0000ou 1111, e que não terminam com 000(porque o próximo caractere deve começar com 0):

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

Aqui estão os caracteres que terminam com 1000. Eles só podem ser usados ​​no final:

• (8HXhx