Il tuo compito: data una stringa di input, determina se la rappresentazione binaria di quella stringa non ha 4 1se 0di fila, ovunque. Inoltre, il codice stesso non dovrebbe contenere tali esecuzioni di quattro di fila.

Casi 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

Regole

L'input sarà sempre all'interno dell'intervallo di ASCII stampabile, inclusi i caratteri degli spazi bianchi.
- Il codice può utilizzare qualsiasi codifica, poiché è importante solo a livello di bit.
Poiché questa condizione impedisce l'uso di spazi bianchi e molti altri caratteri, il codice può effettivamente contenere tali esecuzioni di quattro di fila, con una penalità di 10 byte per ogni esecuzione.
- Una serie di 5 1secondi 0conta come due serie, 6 di fila conta come tre serie, ecc.
L'input sarà una stringa o un array di caratteri, non qualsiasi altra forma.
È possibile scrivere un programma o una funzione completi.
È necessario fornire la rappresentazione binaria del codice nella risposta.

Buona fortuna, il punteggio più basso vince!

Questo script potrebbe aiutarti con la tua sfida, inserire il tuo codice nell'input e ti darà la rappresentazione binaria del tuo codice, la sua lunghezza, la tua penalità e il punteggio totale, se stai usando UTF-8.

Classifica

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Mostra snippet di codice

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

Expand snippet

— Pavel
fonte

1

Sono abbastanza sicuro che lo snippet sia difettoso, ad esempio vedo ||elencato e cioè 0111110001111100.

— Ørjan Johansen

Giusto, buon punto. Un secondo.

— Pavel

2

Sarebbe stato ancora più divertente se il compito fosse trovare il punteggio di una stringa.

— Adám

1

@JonathanAllan bene, nel modo in cui lo intendevo, lo fa, ma dopo ulteriori riflessioni non vedo davvero una ragione per questo, quindi lo cambierò.

— Pavel

1

@Pavel Il punteggio non si basa esclusivamente sui byte se ci sono penalità. Questo lo rende un [codice-sfida], non [codice-golf]. Dal tag wiki: "Se la lunghezza del codice sorgente non è il criterio di punteggio principale, prendere in considerazione l'utilizzo di un altro tag". TL; DR, poiché il punteggio effettivo = / = il conteggio dei byte del programma e il codice più breve non significa ottenere il punteggio migliore, non è [code-golf].

— mbomb007

19

Gelatina , 18 byte + 0 penalità = 18

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

Restituisce 1se non ci sono stringhe di bit uguali di lunghezza 4 o superiore nella rappresentazione di parole a 8 bit dell'ingresso stringa ASCII e in caso 0contrario.

Provalo online! (suite di test con alcuni casi aggiuntivi aggiunti)

Usando la tabella codici di Jelly non ci sono sottostringhe di lunghezza 4 o più lunghe di bit uguali:

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 lunghezze uguali di:

221323221211111312322133122121221111213121123132213111122211311332313211313211111112

Come?

I trucchi per evitare i demeriti sono:

per evitare il "convertito dal carattere ordinale" monad Oconvertendo il numero 79di un carattere usando Ọseguita da una "valutazione di codice Gelatina con ingresso", v.
per evitare la conversione diretta in binario usando B( 0x42, 1000010) con la semplice alternativa a due byte b2usando la conversione base diadica generica.
per evitare alcune scelte normali per il conteggio delle serie di bit uguali - la prima scelta sarebbe "tutte le sezioni sovrapposte di una determinata lunghezza", ṡ( 0xF5o 11110101). Una seconda scelta potrebbe essere quella di utilizzare "tutti gli elenchi secondari", Ẇ( 0xCFo 11001111).
Una soluzione alternativa che ho usato prima di quella corrente è stata quella di prendere gli incrementi (tra elementi consecutivi) con I(mettere gli zeri e quelli su un piano di parità) e cercare ogni occorrenza di tre zeri di fila. Per fare ciò ho convertito tutti gli zeri in uno usando la funzione binomiale con 2cie 2Cx - facendo -1diventare la 0s la 1s diventare 2s, e la 0s diventare1S; in questo modo il codice può cercare la prima occorrenza dell'elenco secondario [1,1,1]con w111.
Tuttavia una via più breve è diventato evidente - di imitare l'azione di "tutte le sezioni sovrapposte di determinata lunghezza", ṡsi può utilizzare un 4 -wise sovrapposizione ridurre con alcune diadi, <dyad>4\. Se questo viene eseguito con addizione, +4\conta la 1s, quindi qualsiasi 0o 4essere presente è l'indicatore per restituire un valore di verità. Il problema qui è che il passo successivo ovvia sarebbe quella di prendere il modulo 4 di quello di mettere le 0e 4voci sullo stesso piano lasciando le altre possibili valori ( 1, 2e 3) invariati, ma +\%4ha\%all'interno, che ha il valore in bit 010111 0000 100100. Per evitare tale penalità, i numeri vengono tutti convertiti in base 4 con b4(mappatura 0in [0], 1a [1], 2a [2], 3a [3]e 4a [1,0]) e l'intero elenco viene appiattito F. Ora l'ultimo test è semplicemente quello di verificare se ci sono messaggi 0nell'elenco, ottenibili direttamente con 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?

Nota: il motivo per cui un 2 viene concatenato con l'elenco ordinale è quello di gestire i casi limite in cui l'unica sequenza di 4 nella stringa di input è negli zeri iniziali del primissimo carattere: questi caratteri sono: tab; avanzamento di riga; e ritorno a capo. Senza questo, la conversione di base 256 rimuove effettivamente gli zeri iniziali dalla stringa binaria (completamente concatenata); con i primi 2 gli zeri iniziali saranno lì e uno in più e zero prima di loro. Poiché nessun ASCII stampabile ha esattamente tre zeri iniziali, non è necessario scartare questi bit extra prima del resto del controllo.

— Jonathan Allan
fonte

Suppongo che potresti semplicemente aggiungere un negato o qualcosa di simile a cui conformarti. Il valore che produci / restituisci per verità e falsità deve essere coerente, che interpreto come "stesso valore ogni volta per verità" e lo stesso per falsità. Anche il tuo vero / falso è opposto a quelli nella domanda.

— Emigna

Ho appena chiesto a questo proposito - quando l'ho letto originariamente (molte ore fa) ho preso "Il valore che produci / restituisci per verità e falsità deve essere coerente." vuol dire che potremmo produrre in entrambi i modi finché resterà allo stesso modo tra una corsa e l'altra. Un negazione diretta produrrà un demerito.

— Jonathan Allan

Potrei sicuramente salvarne anche alcuni se non dovessi farlo. Fino a un punteggio molto basso con la nuova versione a cui sto lavorando. Spero che tu sia quello che ha interpretato correttamente :)

— Emigna

Bene, ho dato un suffisso a due byte che fa il trucco, dando allo stesso modo gli esempi e valori strettamente coerenti di 0e 1se necessario.

— Jonathan Allan

Bello. In attesa di vedere come hai fatto.

— Scendo

12

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

Sto usando newline invece di spazi per cercare di ridurre al minimo la penalità ...

Provalo online!

Binario

01100010011011110110111101101100011001010110000101101110000010100110001000101000011000110110100001100001011100100101101101011101011000100010100101111011010100110111010001110010011010010110111001100111000010100110011100111101001000100010001000111011011001100110111101110010001010000110001101101000011000010111001000001010011000110011101001100010001010010110011100101011001111010110011100101110011001100110111101110010011011010110000101110100001010000010001000100101001000100010101100101000001100010010110100110001001010010010101100100010001110000110010000100010001011000110111001100101011101110000101001001001011011100111010001100101011001110110010101110010001010000100100101101110011101000110010101100111011001010111001000101110011101000110111101010011011101000111001001101001011011100110011100101000011000110010110000110010001010010010100100101001001110110111001001100101011101000111010101110010011011100010000101100111001011100110110101100001011101000110001101101000011001010111001100101000001000100010111000101010001010000010111000101001010111000101110000110001010111000101110000110001010111000101110000110001001011100010101000100010001010010011101101111101

Vecchia soluzione bitshifting 141 byte + 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;}

Provalo online!

Binario

011000100110111101101111011011000110010101100001011011100000101001100010001010000110001101101000011000010111001001011011010111010110001000101001011110110000101001101001011011100111010000001010011011110011110100110000001011000111000000111101001100000010110001101001001110110000101001100110011011110111001000101000011000110110100001100001011100100000101001100011001110100110001000101001011110110110011001101111011100100010100001101001001111010011000000111011011010010011110000111000001110110010100101111011011010010110011000101000001010000110001100100110001010000011000100111100001111000110100100101011001010110010100100101001001111000011000100101001011110110110111100111101001100000011101101110000001010110010101100111011011111010110010101101100011100110110010101111011011100000011110100110000001110110110111100101011001010110011101101111101011010010110011000101000001100110011110001101111011111000011001100111100011100000010100101110010011001010111010001110101011100100110111000001010001101100011110000110101001110110111110101111101011100100110010101110100011101010111001001101110000010100011010100111100001101100011101101111101

— colpire
fonte

Bel trucco con le nuove linee. Conteggio 00000/ 11111come due corse 000000/ / 111111come tre, ecc. Conto 101 corse in totale.

— ETHproductions

@ETHproductions Fixed

— Poke

Questo dovrebbe vincere solo perché Java non è mai stato pensato per questo

— Christopher

10

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

Gli appunti

Contiene una corsa di 4 secondi di 1. Richiede il ⎕IO←0valore predefinito su molti sistemi. Si noti che questo deve essere eseguito su un interprete Classic in modo che le stringhe siano un byte per carattere.

Presentazione

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

Provalo online!

Fonte binaria

_{^{00110001101011001001110010110010100101110101110010111001001010001101011100110100010111001010100010}} 1111_{^{0010111011101010111010101100101001101110101010100010011011001100010001010101}}

Spiegazione

⍞ Richiedi input stringa

11 ⎕DR converti in booleano a 1 bit ( 1 ) D ata R ePresentation

⊂ allegare in modo che possiamo applicare più cose ad esso

(... ) ⍷¨ indicatori binari in cui iniziano le seguenti sequenze ...

× segno (no-op su dati binari, ma incluso come spaziatore per dividere le esecuzioni)

4 \¨ espandi (copia) ciascuno alla lunghezza quattro

⍳ gli interi fino a

≢ il conteggio di

⍬⍬ l'elenco composto da due elenchi numerici vuoti

∊ arruolarsi (appiattire)

⌈\ massimo cumulativo

⌽ inverso

⊃ scegli il primo

1 ≠ è diverso da? (cioè NON)

Procedura dettagliata

Inseriremo "48" nella versione non runata non controllata ~ ∨/ ∊ (0 0 0 0)(1 1 1 1) ⍷¨ ⊂ 11 ⎕DR ⍞:

11 ⎕DR ⍞ converte "48" in 0 0 1 1 0 1 0 0 0 0 1 1 1 0 0 0 (ovvero 52 dicembre 56, esadecimale 34 38)

(0 0 0 0)(1 1 1 1) ⍷¨ ⊂trova gli inizi di 0 e 1 corse; (0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0) (0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)

∨/ ∊cerca se c'è qualche Verità (cioè qualsiasi corsa); 1

~lo nega; 0

— Adamo
fonte

4

Gelatina 28 + 140 demeriti = 168

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

Spiegazione

OB

Converte l'argomento in un elenco delle loro codifiche binarie, ad es

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

Il prossimo pezzo

UÇ€U

risolve il fatto che all'elenco precedente possono mancare caratteri poiché Bnon include zeri iniziali. Ç€chiama il collegamento precedentemente definito su ciascun elemento che lo ripristina

L8_0xṭ

Questo link è equivalente a

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

Per esempio

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

Aggiorniamo l'elenco prima e dopo questa operazione (le due Uchiamate in quell'elenco ) per far sì che sia un antefatto anziché un'appendice. Il prossimo pezzo

FŒr

Appiattisce l'elenco ( F), fornendo la stringa binaria totale della codifica ASCII e la lunghezza di esecuzione codifica l'output ( Œr). Quindi per esempio

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

Infine controlliamo se ogni elemento è <4 (per fortuna questo è sempre vero per 0,1) con

<4F

Per esempio

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

Ạ

Restituisce 0 se uno di questi è errato (in questo caso, 0).

Pagine di codice

Nella codepage di Jelly questo codice è di 20 byte ma ha 27 esecuzioni di violazioni delle regole. In UTF-8 sono 28 byte ma con solo 14 sequenze di violazioni.

— Walpen
fonte

3

05AB1E , 22 + 3 * 10 = 52

Salvato 2 tiri di penalità prendendo in prestito la presa delta dalla risposta Jelly di Jonathan Allan

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

Provalo online!

Spiegazione

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

Rappresentazione binaria del codice

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

Le 3 corse di penalità vengono da vy¦}cui viene utilizzato per tagliare il primo byte in ogni stringa binaria, ma è ancora più economico delle 4 corse che avremmo ottenuto dal più breve €¦.

— Emigna
fonte

@JonathanAllan: ne parlo un po 'alla fine (ma non in dettaglio), ma sfortunatamente la rappresentazione binaria di €in CP-1252 è 10000000che comporta una penalità di 4 da sola.

— Emigna

Ah, anche tu! ... e il mio codice Python per ottenere la rappresentazione non era corretto come ho messo # coding: cp1252in alto> _ <

— Jonathan Allan

3

Perl , 33 + 160 = 193

32 byte di codice + 1 byte per -nflag.

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

(l'input deve essere fornito senza la nuova riga finale. Il link Provalo online è -lcontrassegnato per rimuovere le nuove righe, ma per un singolo input non è necessario).

Provalo online!

xxd dump:

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

Alcune note:

(.)\1\1\1salva qualche penalità (.)\1{3}, 1111|0{4}o qualsiasi altra regex che mi viene in mente (usando 0o ha {}un costo elevato).
printsalva ~ 8 punti sull'uso -pe $_=perché pcontiene una corsa di 4 0whilen non lo fa.
+come delimitatore per il regex salva una sequenza di 1ciò che è dentro /.
fare due passi invece di uno con !~due passaggi ( ~è 01111110in binario).
unpack"B*"è piuttosto costoso (4 corse), ma non sono riuscito a trovare più economico (le soluzioni basate ordsaranno ancora più costose).

— Dada
fonte

3

PHP, 98 + 270 = 368 byte

Volevo adottare un approccio diverso da quello proposto da Titus , e ho concluso con un programma leggermente più lungo, ma meno penalizzato.

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

Uscite 1per la verità, niente per la falsità.

Provalo qui!

Codifica binaria:

0010010001110110001111010111010101101110011100000110000101100011011010110010100
0001001110100100000101010001001110010110000100100011000010111001001100111011101
1001011011001100010101110100101001001110110010010001100101001111010110001001100
0010111001101100101010111110110001101101111011011100111011001100101011100100111
0100001010000010010001110110010110110011000101011101001011000011000100110110001
0110000110010001010010011101101100101011000110110100001101111001000010111001101
1101000111001001101001011100110111010001110010001010000010010001100101001011000
0100111001100000011000000110000001100000010011100101001001001100010011000100001
0111001101110100011100100110100101110011011101000111001000101000001001000110010
1001011000010011100110001001100010011000100110001001001110010100100111011

(22 occorrenze di 0000e 5 occorrenze di 1111, quindi 270 byte di penalità)

— Roberto06
fonte

2

PHP, 86 byte + 370 = 456

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

crea la stringa binaria e usa una regex per rilevare le strisce. L'output è 1per verità; vuoto per falsa.

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

ritocchi

i backreferences risparmiano 100 penalità per 3 byte. (-97 punti)

idee abbandonate

join(array_map(str_split())) costerebbe 31 byte e 90 penalità
e <?=/ $argv[1]invece di echo/ $argncostano altri 2 + 40.
str_pad(decbin())è più costoso di sprintf: 7 byte e 110 penalità.
strtr risparmia 80 penalità per 13 byte extra, ma i riferimenti indietro sono migliori.
Il raggruppamento dei riferimenti secondari #(.)\\1{3}consente di risparmiare 3 byte, ma aggiunge 10 penalità.
foreach costa 3 + 50.
Nessun salvataggio possibile sui nomi delle variabili.
il buffer di output costa 42 + 120.

— Titus
fonte

Aggiungi un §a for(§;per -9.

— Christoph,

2

MATL, 16 byte + 60 = 76 byte

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

Provalo a MATL Online

— Suever
fonte

2

JavaScript (ES8), 91 byte + 430 penalità = 521 totali

Questo produrrà 1per truee 0per false.

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

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000010110110010111000101110001011100111001101011101001011100110110101100001011100000010100001100011001111010011111001100011001011100110001101101000011000010111001001000011011011110110010001100101010000010111010000101000001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110000011000010110010001010011011101000110000101110010011101000010100000110011001010110011010100101100001100010010110100110001001010010010100100101110011010100110111101101001011011100010100000100010001000100010100100101001

Provalo

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

Espandi frammento

— ispido
fonte

padStartnon è in ES6.

— Neil,

Accidenti! Continuo a dimenticare di passare a ES8 ogni volta che lo uso (lo stesso con ES7 e Array.includes()) - grazie, @Neil.

— Shaggy,

1

CJam , 23 byte

Usa l'idea di Jonathan Allan di lavorare con i delta.

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

Provalo online!

Rappresentazione binaria:

00110001011100010011001000110101
00110110011000100011001001100010
00110010011001010111011100111010
00111010001011010101101101010100
01010100010101000101110100100011
001010010110011100101101

Spiegazione:

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
fonte

1

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

Spiegazione

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

1

JavaScript, 173 + 89 * 10 = 1063

JavaScript non è bravo a convertire le stringhe in binario, ma ho pensato di dare una chance a questa sfida solo per divertimento.

Codice:

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

Spiegazione:

Crea una stringa con cui lavorare:

b="";

Passa sopra ogni carattere nella stringa:

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

Crea un array e converti la stringa in binario usando il codice carattere:

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

Aggiungi gli zeri iniziali all'array:

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

Unire nuovamente l'array in una stringa:

b+=c.join("")

Restituisce se nel risultato binario è stata trovata o meno una stringa di quattro o più 1 o 0 usando un'espressione regolare:

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

Violino:

https://jsfiddle.net/vrtLh97c/

Statistiche:

Lunghezza: 173 byte Penalità: 890 Totale: 1063

Code Golf è difficile :)

— StephenRios
fonte

Puoi fornire la rappresentazione binaria del tuo codice e documentare le sanzioni?

— Pavel

Questo ha una penalità di 890 per un punteggio totale di 1063.

— Pavel

Totale aggiunti al post originale.

— StephenRios

1

L'utilizzo 1-1anziché 0in alcuni punti potrebbe farti risparmiare dei demeriti.

— Colpisce il

1

Pyth, 21 + 2 * 10 = 41

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

Provalo online!

Rappresentazione 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

— notjagan
fonte

1

Retina, 101 + 1390 = 1491

Il codice contiene caratteri non stampabili, ma vengono visualizzati in Chrome se modifichi il post. -lo è \x01-\x7f.

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

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

Provalo online

Questo codice utilizza questoord , seguita da conversione binaria e un semplice controllo per la sovrapposizione sequenze di quattro.

In binario:

11000010101101100000101011000010101100010000101001010011010111110110000000001010001001010010100001010011011000001100001010110001000010100111101100110010011000000000101000100100011000000000101001111101010101000011000000110001011000000000000100101101011111110110000001011111011011110000101000101001010011010111001101100000001011100000101000101110001010110000101000100100001010100000101000101011011000000010100000110001001010110010100100000001000010100010010001111011001100010111110100110000000010100011000000110001000010100011000100001010011011010010101101100000010111100010100000111111001000010010111001111011001110000111110100101001000010100011000000001010001100000111101100111000011111010111110011000010101101100000101000001010010011010010011001100000001010000010111000101001000000010111101100110011011111010000101000110000

Pene contate con questo programma Python .

— mbomb007
fonte

Fornisci una rappresentazione hexdump e binaria, poiché contiene non stampabili.

— Pavel

Ho già detto cosa / dove sono gli stampabili, oltre a fornire un programma in grado di stampare la stringa binaria (decommentare la riga in fondo).

— mbomb007

Va bene, allora ..

— Pavel

1

Python 2 , 74 (lunghezza) + 130 (penalità) = 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

L'uscita è tramite il codice di uscita; 0 è vero, 1 è falso. Produce output di immondizia su STDOUT e STDERR.

Provalo online!

Deposito 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

— Dennis
fonte

Ho scoperto che 0è piuttosto brutto da includere. È meglio usare1-1

— Poke

@Poke Ho appena realizzato il mio errore. Il risultato non è stato utilizzato, quindi non sono sicuro del motivo per cui ho scelto 0in primo luogo.

— Dennis

1

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

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

In binario:

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000011100110010111001110010011001010111000001101100011000010110001101100101001010000010111101011011010111000101001101011100011100110101110100101111011001110010110001100011001111010011111000101000001100100011010100110110001010110110001100101110011000110110100001100001011100100100001101101111011001000110010101000001011101000010100000101001001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110011011011000110100101100011011001010010100000110001001010010010100100101001

Oltre la metà della pena è fino a zero nella sovrapposizione tra i byte, piuttosto che le corse nelle seguenti caratteri: =>//pa//=>aCoAo.

Dato che /s ( 00101111) paga una penalità ho provato a) passare da testa matchb) passare da replacea mapma il punteggio è sempre finito più alto. Tuttavia ho scoperto che è [\S\s]stato un miglioramento [^]. Modifica: complessivamente salvati 9 byte grazie a @Shaggy.

— Neil
fonte

Penso che la |classe dei personaggi non dovrebbe essere lì

— ETHproductions

@ETHproductions Ho capito bene nella mia spiegazione ...

— Neil

Potresti radere 10 del tuo rigore sostituendo il !con 1-un totale di 468. E potresti fare un ulteriore risparmio di 5 byte sostituendo [\S\s]con .un totale di 463.

— Shaggy

@Shaggy Grazie, anche se non sono sicuro che i newline siano considerati stampabili, quindi per ora lo farò al sicuro.

— Neil,

Js supporta un flag regex multilinea? In tal caso, potresti accettare il suggerimento di Shaggy e aggiungere il flag per salvare ancora i byte.

— Pavel,

1

Pyth , 16 + 1 x 10 = 26 byte

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

Provalo online!

Binario

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

Trucchi

Le seguenti alternative sono fatte per evitare i demeriti:

Utilizzando qZ(è uguale a zero) invece di! (annulla)
Utilizzo di :xy0(cerca) anziché }xy(è la lista secondaria)
Utilizzo di Z(variabile, impostazione predefinita a zero) anziché 0(zero stesso)

miglioramenti

Non trovo alcun modo per eludere la sanzione. Abbiamo questi comandi relativi al binario:

.Bbinario ( 00101110 01[0000]10)
Ccharcode ( 01[0000]11)
.Oottario ( 00101110 0100[1111])
.Hesadecimale ( 00101110 01001[000)

Nota che .Hci darà anche una penalità, perché ogni personaggio stampabile ha la sua rappresentazione binaria a partire da 0. Pertanto, ho usato quello più diretto, che è.B convertendolo direttamente in binario.

Posso finire con .H per evitare la penalità, ma mi costa 27 byte ...

Generazione

Ho trovato tutti i caratteri consentiti, che sono quelli che non contengono 0000o 1111e che non terminano 000(poiché il carattere successivo deve iniziare con 0):

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

Ecco i personaggi che finiscono con 1000. Possono essere utilizzati solo alla fine:

(8HXhx

— Perdente Suora
fonte

Scollegare 4 bit

Casi test

Regole

Classifica

Gelatina , 18 byte + 0 penalità = 18

Come?

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

Binario

Vecchia soluzione bitshifting 141 byte + 10 * 101 = 1.151

Binario

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

Gli appunti

Presentazione

Fonte binaria

Spiegazione

Procedura dettagliata

Gelatina 28 + 140 demeriti = 168

Spiegazione

Pagine di codice

05AB1E , 22 + 3 * 10 = 52

Perl , 33 + 160 = 193

PHP, 98 + 270 = 368 byte

PHP, 86 byte + 370 = 456

MATL, 16 byte + 60 = 76 byte

JavaScript (ES8), 91 byte + 430 penalità = 521 totali

Provalo

CJam , 23 byte

Pyth, 19 + 12 * 10 = 139

Binario

Spiegazione

JavaScript, 173 + 89 * 10 = 1063

Codice:

Binario:

Spiegazione:

Violino:

Statistiche:

Pyth, 21 + 2 * 10 = 41

Retina, 101 + 1390 = 1491

Python 2 , 74 (lunghezza) + 130 (penalità) = 204

Deposito binario

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

Pyth , 16 + 1 x 10 = 26 byte

Binario

Trucchi

miglioramenti

Generazione