Su tarea: dada una cadena de entrada, determine si la representación binaria de esa cadena no tiene 4 1so 0s en una fila, en ninguna parte. Además, su código en sí mismo no debe contener ninguna ejecución de este tipo de cuatro seguidas.

Casos de prueba

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

Reglas

• La entrada siempre estará dentro del rango de ASCII imprimible, incluidos los espacios en blanco.
  • Su código puede usar cualquier codificación, ya que solo importa a nivel de bit.
• Debido a que esta condición impide el uso de espacios en blanco y muchos otros caracteres, su código puede contener tales ejecuciones de cuatro seguidas, con una penalización de 10 bytes por cada ejecución.
  • Una carrera de 5 1so 0s cuenta como dos carreras, 6 seguidas cuenta como tres carreras, etc.
• La entrada será una cadena o matriz de caracteres, no cualquier otra forma.
• Puede escribir un programa o función completa.
• Debe proporcionar la representación binaria de su código en su respuesta.

¡Buena suerte, gana el puntaje más bajo!

Este script puede ayudarlo con su desafío, poner su código en la entrada y le dará la representación binaria de su código, su longitud, su penalización y la puntuación total, si está utilizando UTF-8.

Tabla de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores 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>

Gelatina , 18 bytes + 0 penalizaciones = 18

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

Devuelve 1si no hay cadenas de bits iguales de longitud 4 o más en la representación de palabras de 8 bits de la entrada de cadena ASCII, y de lo 0contrario.

Pruébalo en línea! (conjunto de pruebas con algunos casos adicionales agregados)

Usando la página de códigos de Jelly no hay subcadenas de 4 o más largos de bits iguales:

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

Con longitudes de ejecución de bits iguales de:

221323221211111312322133122121221111213121123132213111122211311332313211313211111112

¿Cómo?

Los trucos para evitar deméritos son:

• para evitar el "convertido del carácter a ordinal" mónada Omediante la conversión del número 79a un personaje usando Ọseguida de una "evaluación de código Jelly con entrada", v.

• para evitar la conversión directa a binario usando B( 0x42, 1000010) mediante la alternativa simple de dos bytes b2usando la conversión de base diádica genérica.

• para evitar algunas elecciones normales para contar las corridas de bits iguales, la primera opción sería "todas las partes superpuestas de longitud dada", ṡ( 0xF5o 11110101). Una segunda opción podría ser utilizar "todas las sublistas", Ẇ( 0xCFo 11001111).
  Una solución alternativa que utilicé antes que la actual era tomar los incrementos (entre elementos consecutivos) con I(poner ceros y unos en pie de igualdad), y buscar cualquier ocurrencia de tres ceros seguidos. Para hacer eso, convertí todos los ceros a unos mediante el uso de la función binomial, 2ces decir, 2Cx , haciendo que la -1s se convierta en 0s, la 1s se convierta en 2s, y la 0s se convierta en1s; de esa manera el código puede buscar la primera aparición de la sublista [1,1,1]con w111.
  Sin embargo, se hizo evidente una forma más corta: para imitar la acción de "todas las rebanadas superpuestas de una longitud determinada" ṡ, se puede usar una reducción superpuesta de 4 direcciones con alguna diada <dyad>4\. Si esto se realiza con suma, +4\cuenta el 1s, entonces cualquiera 0o 4estar presente es el indicador para devolver un valor verdadero. El problema aquí es que el siguiente paso obvio sería la de tomar el módulo 4 del que poner los 0y las 4entradas en igualdad de condiciones, dejando los otros valores posibles ( 1, 2y 3) sin cambios, pero +\%4tiene\%dentro, que tiene un valor de bit 010111 0000 100100. Para evitar esa penalización, todos los números se convierten a base 4 con b4(asignación 0a [0], 1a [1], 2a [2], 3a [3]y 4a [1,0]) y se aplana toda la lista F. Ahora, la última prueba es simplemente verificar si hay alguna 0s en la lista, que se pueda lograr directamente con la 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: La razón por la que un 2 se concatena con la lista ordinal es para tratar los casos de borde donde la única ejecución de 4 en la cadena de entrada está en los ceros iniciales del primer carácter: estos caracteres son: tabulación; linea de alimentación; y retorno de carro. Sin esto, la conversión de base 256 elimina efectivamente los ceros iniciales de la cadena binaria (totalmente concatenada); con los primeros 2 los ceros iniciales estarán allí y uno adicional y cero antes de ellos. Como ningún ASCII imprimible tiene exactamente tres ceros iniciales, no es necesario descartar estos bits adicionales antes del resto de la comprobación.

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

Estoy usando líneas nuevas en lugar de espacios para tratar de minimizar la penalización ...

Pruébalo en línea!

Binario

01100010011011110110111101101100011001010110000101101110000010100110001000101000011000110110100001100001011100100101101101011101011000100010100101111011010100110111010001110010011010010110111001100111000010100110011100111101001000100010001000111011011001100110111101110010001010000110001101101000011000010111001000001010011000110011101001100010001010010110011100101011001111010110011100101110011001100110111101110010011011010110000101110100001010000010001000100101001000100010101100101000001100010010110100110001001010010010101100100010001110000110010000100010001011000110111001100101011101110000101001001001011011100111010001100101011001110110010101110010001010000100100101101110011101000110010101100111011001010111001000101110011101000110111101010011011101000111001001101001011011100110011100101000011000110010110000110010001010010010100100101001001110110111001001100101011101000111010101110010011011100010000101100111001011100110110101100001011101000110001101101000011001010111001100101000001000100010111000101010001010000010111000101001010111000101110000110001010111000101110000110001010111000101110000110001001011100010101000100010001010010011101101111101

Antigua solución de desplazamiento 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;}

Pruébalo en línea!

Binario

011000100110111101101111011011000110010101100001011011100000101001100010001010000110001101101000011000010111001001011011010111010110001000101001011110110000101001101001011011100111010000001010011011110011110100110000001011000111000000111101001100000010110001101001001110110000101001100110011011110111001000101000011000110110100001100001011100100000101001100011001110100110001000101001011110110110011001101111011100100010100001101001001111010011000000111011011010010011110000111000001110110010100101111011011010010110011000101000001010000110001100100110001010000011000100111100001111000110100100101011001010110010100100101001001111000011000100101001011110110110111100111101001100000011101101110000001010110010101100111011011111010110010101101100011100110110010101111011011100000011110100110000001110110110111100101011001010110011101101111101011010010110011000101000001100110011110001101111011111000011001100111100011100000010100101110010011001010111010001110101011100100110111000001010001101100011110000110101001110110111110101111101011100100110010101110100011101010111001001101110000010100011010100111100001101100011101101111101

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

Notas

Contiene un 4 corridas de 1s. Requiere ⎕IO←0cuál es el predeterminado en muchos sistemas. Tenga en cuenta que esto debe ejecutarse en un intérprete clásico para que las cadenas sean de un byte por carácter.

Sumisión

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

Pruébalo en línea!

Fuente binaria

_{^{00110001101011001001110010110010100101110101110010111001001010001101011100110100010111001010100010}} 1111 _{^{00101110111010101110101011001010011011101010101000100110110011000100110001100011000100010001010010100010001010010100010001010010100010001010010100010001010010100010}}

Explicación

⍞ Solicitar entrada de cadena

11 ⎕DR convertir a 1 bit Boolean ( 1 ) D ata R epresentación

⊂ adjuntar para que podamos aplicarle varias cosas

(... ) ⍷¨ indicadores binarios donde comienza cada una de las siguientes secuencias ...

 × signo (no operativo en datos binarios, pero incluido como espaciador para dividir ejecuciones)

 4 \¨ expandir (copiar) cada uno a la longitud cuatro

 ⍳ los enteros hasta

 ≢ la cuenta de

 ⍬⍬  la lista que consta de dos listas numéricas vacías

∊ alistarse (aplanar)

⌈\ máximo acumulativo

⌽ marcha atrás

⊃ elige el primero

1 ≠ es uno diferente de? (es decir, NO)

Recorrido

Ingresaremos "48" a la versión no corregida sin golf ~ ∨/ ∊ (0 0 0 0)(1 1 1 1) ⍷¨ ⊂ 11 ⎕DR ⍞:

11 ⎕DR ⍞ convierte "48" en 0 0 1 1 0 1 0 0 0 0 1 1 1 0 0 0 (es decir, 52 de diciembre 56, Hex 34 38)

(0 0 0 0)(1 1 1 1) ⍷¨ ⊂encuentra comienzos de 0 carreras y 1 carreras; (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)

∨/ ∊mira si hay alguna Verdad (es decir, alguna ejecución); 1

~niega eso; 0 0

Gelatina 28 + 140 deméritos = 168

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

Explicación

OB

Convierte el argumento en una lista de sus codificaciones binarias, p. Ej.

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

La siguiente pieza

UÇ€U

corrige el hecho de que en la lista anterior pueden faltar caracteres, ya Bque no incluye ceros a la izquierda. Ç€llama al enlace previamente definido sobre cada elemento que restaura ese

L8_0xṭ

Este enlace es equivalente a

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

Por ejemplo

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

Cambiamos la lista antes y después de esta operación (las dos Ullamadas en esa lista) para que sea un antecedente en lugar de un anexo. La siguiente pieza

FŒr

Aplana la lista ( F), dando la cadena binaria total de la codificación ASCII, y la longitud de ejecución codifica la salida ( Œr). Así por ejemplo

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

y

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 si cada elemento es <4 (afortunadamente, esto siempre es cierto para 0,1) con

<4F

Por ejemplo

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

Ạ

Devuelve 0 si alguno de ellos es falso (en este caso, 0).

Páginas de códigos

En la página de códigos de Jelly, este código tiene 20 bytes pero tiene 27 ejecuciones de violaciones de reglas. En UTF-8 es de 28 bytes pero con solo 14 ejecuciones de violaciones.

05AB1E , 22 + 3 * 10 = 52

Salvó 2 ejecuciones de penalización tomando prestado el truco delta de la respuesta de Jonathan Allan's Jelly

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

Pruébalo en línea!

Explicación

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

Representación binaria del código.

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

Las 3 ejecuciones de penalización provienen de las vy¦}cuales se utiliza para cortar el primer byte en cada cadena binaria, pero aún así es más barato que las 4 ejecuciones que obtendríamos de la más corta €¦.

Perl , 33 + 160 = 193

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

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

(la entrada debe proporcionarse sin una nueva línea final. El enlace Probar en línea tiene -lmarcado para eliminar nuevas líneas, pero para una sola entrada, no es necesario).

Pruébalo en línea!

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

Algunas notas

• (.)\1\1\1ahorra unos sanciones sobre (.)\1{3}, 1111|0{4}o cualquier otra expresión regular que podía pensar (con 0o {}tiene un costo pesado).
• printahorra ~ 8 puntos sobre el uso -py $_=porque pcontiene una carrera de 4 0mientras nque no lo hace.
• +como un delimitador para la expresión regular guarda una corrida de 1eso está en /.
• haciendo dos pasos en lugar de uno con !~guardar dos ejecuciones ( ~está 01111110en binario).
• unpack"B*"es bastante caro (4 carreras), pero no pude encontrarlo más barato (las soluciones basadas ordserán aún más caras).

PHP, 98 + 270 = 368 bytes

Quería adoptar un enfoque diferente de lo que Titus propuso , y terminé con un programa un poco más largo, pero menos penalizado.

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

Salidas 1para la verdad, nada para falsey.

Pruébalo aquí!

Codificado en binario:

0010010001110110001111010111010101101110011100000110000101100011011010110010100
0001001110100100000101010001001110010110000100100011000010111001001100111011101
1001011011001100010101110100101001001110110010010001100101001111010110001001100
0010111001101100101010111110110001101101111011011100111011001100101011100100111
0100001010000010010001110110010110110011000101011101001011000011000100110110001
0110000110010001010010011101101100101011000110110100001101111001000010111001101
1101000111001001101001011100110111010001110010001010000010010001100101001011000
0100111001100000011000000110000001100000010011100101001001001100010011000100001
0111001101110100011100100110100101110011011101000111001000101000001001000110010
1001011000010011100110001001100010011000100110001001001110010100100111011

(22 ocurrencias 0000y 5 ocurrencias de 1111, por lo tanto, 270 bytes de penalización)

PHP, 86 bytes + 370 = 456

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

crea la cadena binaria y usa una expresión regular para detectar rayas. La salida es 1para la verdad; vacío por falsedad.

Corre con echo '<string>' | php -nR '<code>'.

ajustes

• Las referencias posteriores ahorran 100 penalizaciones por 3 bytes. (-97 puntaje)

ideas abandonadas

• join(array_map(str_split())) costaría 31 bytes y 90 de penalización
• y <?=/ en $argv[1]lugar de echo/ $argncuesta otros 2 + 40.
• str_pad(decbin())es más costoso que sprintf: 7 bytes y 110 penalizaciones.
• strtr ahorra 80 penalizaciones por 13 bytes adicionales, pero las referencias son mejores.
• Agrupar las referencias posteriores #(.)\\1{3}ahorra 3 bytes, pero agrega 10 penalizaciones.
• foreach cuesta 3 + 50.
• No es posible guardar en los nombres de las variables.
• el buffering de salida cuesta 42 + 120.

MATL, 16 bytes + 60 = 76 bytes

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

Pruébalo en MATL Online

JavaScript (ES8), 91 bytes + 430 de penalización = 521 en total

Esto generará 1para truey 0para false.

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

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000010110110010111000101110001011100111001101011101001011100110110101100001011100000010100001100011001111010011111001100011001011100110001101101000011000010111001001000011011011110110010001100101010000010111010000101000001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110000011000010110010001010011011101000110000101110010011101000010100000110011001010110011010100101100001100010010110100110001001010010010100100101110011010100110111101101001011011100010100000100010001000100010100100101001

Intentalo

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

Utiliza la idea de Jonathan Allan para trabajar con deltas.

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

Pruébalo en línea!

Representación binaria:

00110001011100010011001000110101
00110110011000100011001001100010
00110010011001010111011100111010
00111010001011010101101101010100
01010100010101000101110100100011
001010010110011100101101

Explicación:

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

Binario

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

Explicación

!|}*"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 no es bueno para convertir cadenas a binario, pero pensé que probaría este desafío solo por diversión.

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}

Binario:

0110011001110101011011100110001101110100011010010110111101101110001010000110111000101001011110110110001000111101001000100010001000111011011001100110111101110010001010000111011001100001011100100010000001110100001111010011000000111011011101000011110001101110001011100110110001100101011011100110011101110100011010000011101101110100001010110010101100101001011000110011110101011011011011100010111001100011011010000110000101110010010000110110111101100100011001010100000101110100001010000111010000101001001011100111010001101111010100110111010001110010011010010110111001100111001010000011001000101001010111010010110001100011001011100111010101101110011100110110100001101001011001100111010000101000010000010111001001110010011000010111100100101000001110000010110101100011010110110011000001011101001011100110110001100101011011100110011101110100011010000010101100110001001010010010111001101010011011110110100101101110001010000011000000101001001010010010110001100010001010110011110101100011001011100110101001101111011010010110111000101000001000100010001000101001001110110111001001100101011101000111010101110010011011100010000001100010001011100110110101100001011101000110001101101000001010000010111101011011001100010101110101111011001101000010110001111101011111000101101100110000010111010111101100110100001011000111110100101111011001110010100100111111001000010011000100111010001000010011000001111101

Explicación:

Crea una cadena para trabajar con:

b="";

Pase sobre cada carácter en la cadena:

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

Cree una matriz y convierta la cadena a binario usando el código de caracteres:

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

Agregue los ceros iniciales a la matriz:

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

Únete a la matriz de nuevo en una cadena:

b+=c.join("")

Devuelva si se encontró o no una cadena de cuatro o más 1 o 0 en el resultado binario usando una expresión regular:

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

Violín:

https://jsfiddle.net/vrtLh97c/

Estadísticas:

Longitud: 173 bytes Penalización: 890 Total: 1063

Code Golf es difícil :)

Pyth, 21 + 2 * 10 = 41

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

Pruébalo en línea!

Representación binaria:

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

El código contiene caracteres no imprimibles, pero aparecen en Chrome si edita la publicación. -es \x01-\x7f.

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

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

Pruébalo en línea

Este código usa estoord , seguido de la conversión a binario y una simple comprobación de secuencias superpuestas de cuatro.

En binario:

11000010101101100000101011000010101100010000101001010011010111110110000000001010001001010010100001010011011000001100001010110001000010100111101100110010011000000000101000100100011000000000101001111101010101000011000000110001011000000000000100101101011111110110000001011111011011110000101000101001010011010111001101100000001011100000101000101110001010110000101000100100001010100000101000101011011000000010100000110001001010110010100100000001000010100010010001111011001100010111110100110000000010100011000000110001000010100011000100001010011011010010101101100000010111100010100000111111001000010010111001111011001110000111110100101001000010100011000000001010001100000111101100111000011111010111110011000010101101100000101000001010010011010010011001100000001010000010111000101001000000010111101100110011011111010000101000110000

Las penalizaciones cuentan con este programa Python .

Python 2 , 74 (longitud) + 130 (penalización) = 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 salida es a través del código de salida; 0 es verdadero, 1 es falso. Produce salida de basura a STDOUT y STDERR.

Pruébalo en línea!

Volcado binario

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 + 390380 = 477 468 bytes

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

En binario:

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000011100110010111001110010011001010111000001101100011000010110001101100101001010000010111101011011010111000101001101011100011100110101110100101111011001110010110001100011001111010011111000101000001100100011010100110110001010110110001100101110011000110110100001100001011100100100001101101111011001000110010101000001011101000010100000101001001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110011011011000110100101100011011001010010100000110001001010010010100100101001

Más de la mitad de la pena se ha reducido a ceros en el solapamiento entre bytes, en lugar de las carreras en los siguientes caracteres: =>//pa//=>aCoAo.

Dado que /s ( 00101111) paga una penalización, intenté a) cambiar de testa matchb) cambiar de replacea mappero la puntuación siempre terminó más alta. Sin embargo, descubrí que [\S\s]era una mejora [^]. Editar: guardado 9 bytes en general gracias a @Shaggy.

Pyth , 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

Pruébalo en línea!

Binario

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

Trucos

Se realizan las siguientes alternancias para evitar los deméritos:

• Usar qZ(es igual a cero) en lugar de !(negar)
• Usar :xy0(buscar) en lugar de }xy(es sublista)
• Usar Z(variable, predeterminado a cero) en lugar de 0(cero en sí)

Mejoras

No encuentro ninguna forma de eludir la pena. Tenemos estos comandos relacionados con binarios:

• .Bbinario ( 00101110 01[0000]10)
• Ccharcode ( 01[0000]11)
• .Ooctary ( 00101110 0100[1111])
• .Hhexadecimal ( 00101110 01001[000)

Tenga en cuenta que .Htambién nos dará una penalización, porque cada carácter imprimible tiene su representación binaria que comienza con 0. Por lo tanto, utilicé el más directo, que es .Bconvertirlo directamente a binario.

Puedo terminar .Hpara evitar la penalización, pero me cuesta 27 bytes ...

Generacion

Encontré todos los caracteres permitidos, que son aquellos que no contienen 0000o 1111, y que no terminan con 000(porque el siguiente carácter debe comenzar con 0):

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

Aquí están los personajes que terminan con 1000. Solo se pueden usar al final:

• (8HXhx