Göreviniz: bir giriş dizesi verildiğinde, bu dizenin ikili gösteriminin bir yerde, herhangi bir yerde 4 1s veya 0s olup olmadığını belirleyin . Ayrıca, kodunuzun kendisi, arka arkaya dört böyle bir işlem içermemelidir.

Test Kılıfları

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

kurallar

Giriş, her zaman beyaz boşluk karakterleri dahil yazdırılabilir ASCII aralığında olacaktır.
- Kodunuz yalnızca bit düzeyinde önemli olduğundan kodlamayı kullanabilir.
Bu koşul, beyaz boşlukların ve diğer birçok karakterin kullanılmasını önlediği için, kodunuz gerçekte , her çalıştırma için 10 baytlık bir cezada dört satırlık satır içerebilir.
- 5 1sn veya 0s'lik bir işlem iki işlem olarak sayılır, arka arkaya 6 işlem üç işlem sayılır vb.
Giriş bir dize veya karakter dizisi olacaktır, başka bir biçimde değil.
Tam bir program veya işlev yazabilirsiniz.
Cevaplarınızda kodunuzun ikili gösterimini sağlamalısınız.

İyi şanslar, en düşük puan kazanır!

Bu komut dosyası size zorluk konusunda yardımcı olabilir, kodunuzu girdiye sokar ve UTF-8 kullanıyorsanız kodunuzun ikili gösterimini, uzunluğunu, cezanızı ve toplam puanınızı verir.

Liderler Sıralaması

Burada hem düzenli bir lider tablosu hem de kazananların dile göre genel bir bakışı oluşturmak için bir Stack Snippet'i var.

Kod pasajını göster

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

Parçacığı genişlet

— Pavel
kaynak

1

Snippet'in arabası olduğundan oldukça eminim, örneğin ||listelendiğini görüyorum 0111110001111100.

— Ørjan Johansen

Doğru, iyi nokta. Bir saniye.

— Pavel

2

Görev bir dizgenin puanını bulmak olsaydı daha da eğlenceli olurdu.

— Adám

1

@JonathanAllan, istediğim gibi, öyle, ancak daha fazla yansıma üzerine bunun için bir neden göremiyorum, bu yüzden değiştireceğim.

— Pavel

1

@Pavel Puanlama, ceza varsa, yalnızca baytlara dayanmaz. Bu, [kod-golf] değil, [kod-meydan okuma] yapar. Wiki etiketinden: "Kaynak kod uzunluğu birincil puanlama kriteri değilse, bunun yerine başka bir etiket kullanmayı düşünün." TL; DR, asıl puan = / = programın bayt sayısı ve en kısa kod en iyi puanı almak anlamına gelmediğinden, [kod-golf] değil.

— mbomb007

19

Jöle , 18 bayt + 0 penaltı = 18

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

İade 1eşi bit uzunluğunda dizeleri varsa 4 ASCII dize girişinin 8 bitlik kelime temsilinde veya üzeri ve 0aksi.

Çevrimiçi deneyin! (bazı ekstra vakalar eklenmiş test takımı)

Jelly'in kod sayfasını kullanarak uzunluğu 4 veya daha uzun olan eşit bit alt dizgileri yoktur:

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

Eşit bit çalışma uzunlukları:

221323221211111312322133122121221111213121123132213111122211311332313211313211111112

Nasıl?

Demerits önlemek için püf noktaları şunlardır:

" Giriş kodlu jöle kodunun değerlendirilmesi" ile takip edilen Osayıyı 79karaktere dönüştürerek "karakterden sıralıya dönüştürme " monadini önlemek ,.Ọv
B( 0x42, 1000010) b2kullanarak genel dyadik baz dönüşümünü kullanarak basit iki-byte alternatifini kullanarak ikiliye doğrudan dönüşümden kaçınmak .
Eşit bitlerin sayımlarını saymak için birkaç normal seçimlerden kaçınmak için - ilk seçenek "verilen uzunluktaki tüm örtüşen dilimler", ṡ( 0xF5veya 11110101) olacaktır. İkinci bir seçenek "tüm alt listeleri", Ẇ( 0xCFveya 11001111) kullanmak olabilir .
Aktüel olandan önce kullandığım bir geçici çözüm, art arda (ardışık elemanlar arasında) I(sıfırları ve eşit bir temele koyarak ) artımları almak ve art arda üç tane sıfırın oluşumunu araştırmaktı. Birlikte binom fonksiyonu kullanılarak olanlara bütün sıfırları dönüştürülen Bunu yapmak için 2cyani 2CX - yapım -1haline s 0s 1s haline 2ler ve 0lar haline1s; Bu arada bu kod alt liste ilk geçtiği bakabilirsiniz [1,1,1]ile w111.
Bununla birlikte, daha kısa bir yol ortaya çıktı - "verilen uzunluktaki bütün örtüşen dilimlerin" hareketini taklit etmek için ṡ, biri bazı dyadlarla 4- yönlü örtüşen bir azaltma kullanabilir <dyad>4\. Eğer bu ilave ile yapılırsa +4\, 1s'yi sayar , o zaman herhangi biri 0ya da var 4olmak bir hakikat değeri döndüren göstergedir. Burada sorunu önümüzdeki bariz adım modüle almak için olacağıdır 4 koymak için bundan 0ve 4(diğer olası değerleri bırakarak eşit düzeyde girdileri 1, 2ve 3) değişmeden, ama +\%4vardır\%içinde, bit değeri 010.111 olan 0000 bu ceza önlemek için 100100. numaraları tüm baza dönüştürülür 4 ile b4(eşleme 0için [0], 1için [1], 2için [2], 3için [3], ve 4karşı [1,0]) ile düzleştirilir bütün liste F. Şimdi son test, 0doğrudan monad ile elde edilebilecek listede bir liste olup olmadığını kontrol etmektir Ạ.

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?

Not: Bir 2'nin sıra listesiyle birleştirilmesinin nedeni , giriş dizesindeki tek 4 satırının ilk karakterin baştaki sıfırlarında olduğu kenar durumlarıyla ilgilenmektir - bu karakterler: tab; satır besleme; ve taşıma iadesi. Bu olmadan, temel 256 dönüşümü (tamamen birleştirilmiş) ikili diziden baştaki sıfırları etkili bir şekilde çıkarır; lider ile 2 başında sıfır olacak ve onlardan önce fazladan bir ve sıfır. Yazdırılabilir hiçbir ASCII'nin tam olarak üç tane önde sıfır olmadığı için, kontrolün geri kalanından önce bu ekstra bitleri atmaya gerek yoktur.

— Jonathan Allan
kaynak

Sadece bir olumsuzluk veya buna benzer bir şey ekleyebileceğinizi varsayalım. Gerçeği ve sahtekarlık için çıktı / iade değeriniz, "her seferinde aynı değer" ve sahtekârlık için aynı değer olarak yorumladığım tutarlı olmalıdır . Ayrıca sizin doğru / yanlışınız sorudakilerin karşısında.

— Emigna

Ben sadece bunu sordum - ilk defa okuduğumda (birkaç saat önce) "Doğruluk ve sahtekarlık için çıktı / dönüş değeri tutarlı olmalı." Yani, koşular arasında aynı şekilde kaldığı sürece herhangi bir şekilde çıktısını alabildiğimiz anlamına gelirdi.

— Jonathan Allan,

Bunu yapmak zorunda kalmazsam, kesinlikle bazılarını da kurtarabilirim. Üzerinde çalıştığım yeni sürümle birlikte çok düşük bir puan aldı. Umarım doğru yorumlanmış olan sensin :)

— Emigna

Eh ben örnekler ve kesinlikle tutarlı değerler olarak etrafında her ikisi de aynı şekilde vererek hile yok iki bayt eki verdik 0ve 1eğer gerekirse.

— Jonathan Allan,

Güzel. Nasıl yaptığını görmek için bekliyorum. Bütün

— aşağılıkları

12

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

Cezayı en aza indirmeye çalışmak için boşluklar yerine yeni çizgiler kullanıyorum ...

Çevrimiçi deneyin!

İkili

01100010011011110110111101101100011001010110000101101110000010100110001000101000011000110110100001100001011100100101101101011101011000100010100101111011010100110111010001110010011010010110111001100111000010100110011100111101001000100010001000111011011001100110111101110010001010000110001101101000011000010111001000001010011000110011101001100010001010010110011100101011001111010110011100101110011001100110111101110010011011010110000101110100001010000010001000100101001000100010101100101000001100010010110100110001001010010010101100100010001110000110010000100010001011000110111001100101011101110000101001001001011011100111010001100101011001110110010101110010001010000100100101101110011101000110010101100111011001010111001000101110011101000110111101010011011101000111001001101001011011100110011100101000011000110010110000110010001010010010100100101001001110110111001001100101011101000111010101110010011011100010000101100111001011100110110101100001011101000110001101101000011001010111001100101000001000100010111000101010001010000010111000101001010111000101110000110001010111000101110000110001010111000101110000110001001011100010101000100010001010010011101101111101

Eski parça değiştirme çözümü 141 bayt + 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;}

Çevrimiçi deneyin!

İkili

011000100110111101101111011011000110010101100001011011100000101001100010001010000110001101101000011000010111001001011011010111010110001000101001011110110000101001101001011011100111010000001010011011110011110100110000001011000111000000111101001100000010110001101001001110110000101001100110011011110111001000101000011000110110100001100001011100100000101001100011001110100110001000101001011110110110011001101111011100100010100001101001001111010011000000111011011010010011110000111000001110110010100101111011011010010110011000101000001010000110001100100110001010000011000100111100001111000110100100101011001010110010100100101001001111000011000100101001011110110110111100111101001100000011101101110000001010110010101100111011011111010110010101101100011100110110010101111011011100000011110100110000001110110110111100101011001010110011101101111101011010010110011000101000001100110011110001101111011111000011001100111100011100000010100101110010011001010111010001110101011100100110111000001010001101100011110000110101001110110111110101111101011100100110010101110100011101010111001001101110000010100011010100111100001101100011101101111101

— dürtme
kaynak

Newlines ile güzel hile. Sayma 00000/ 11111iki çalışma olarak, 000000/ 111111üç olarak vs.

— ETHproductions

@ETHproductions Sabit

— Poke

Java bunun için asla amaçlanmadığı için bu sadece kazanmalı

— Christopher

10

APL (Dyalog Klasik) , 26 + 1 × 10 = 36 bayt

notlar

Bir 4-run 1s içerir. ⎕IO←0Birçok sistemde varsayılan olanı gerektirir . Bunun bir Klasik yorumlayıcıda çalıştırılması gerektiğini , böylece karakterlerin karakter başına bir bayt olması gerektiğini unutmayın .

boyun eğme

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

Çevrimiçi deneyin!

İkili kaynak

_{^{00110001101011001001110010110010100101110101110010111001001010001101011100110100010111001010100010}} 1111_{^{0010111011101010111010101100101001101110101010100010011011001100010011000110001100010001000101001010001101}}

açıklama

⍞ Dize girişi istemi

11 ⎕DR1- bit Boole ( 1 ) ' ye dönüştürün D ata R çevirisi

⊂ Buraya birden çok şey uygulayabilmemiz için

(… ) ⍷¨ Aşağıdaki dizilerin her birinin başladığı ikili göstergeler…

× işareti (ikili verilerde çalışmaz, ancak işlemleri bölmek için boşluk olarak dahil edilir)

4 \¨ her birini dört olacak şekilde genişlet

⍳ tam sayıları

≢ taksiti

⍬⍬ iki boş sayısal listeden oluşan liste

∊ enlist (düzleştirmek)

⌈\ kümülatif maksimum

⌽ ters

⊃ ilkini seç

1 ≠ biri farklı mı (yani DEĞİL)

Walk-yoluyla

Unung-un-run-runed versiyonuna "48" yazacağız ~ ∨/ ∊ (0 0 0 0)(1 1 1 1) ⍷¨ ⊂ 11 ⎕DR ⍞:

11 ⎕DR ⍞ "48" 'i 0 0 1 1 0 1 0 0 0 0 0 1 1 1 0 0 0 (yani Ara 52 56, Hex 34 38) dönüştürür

(0 0 0 0)(1 1 1 1) ⍷¨ ⊂0 run ve 1 run'un başlangıcını bulur; (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)

∨/ ∊Herhangi bir Gerçek var mı (yani herhangi bir koşma) olup olmadığına bakar; 1

~Bunu reddeder; 0

— Adem
kaynak

4

Jelly 28 + 140 görevliler = 168

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

açıklama

OB

Argümanı ikili kodlamalarının bir listesine dönüştürür, örn.

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

Sonraki parça

UÇ€U

Yukarıdaki listenin Bbaştaki sıfırları içermediği için eksik karakterler olabileceği gerçeğini düzeltir . Ç€geri yükleyen her öğe üzerinde önceden tanımlanmış bağlantıyı çağırır.

L8_0xṭ

Bu bağlantı şuna eşittir

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

Örneğin

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

Bu işlemden önce ve sonra ( Ubu listedeki iki çağrı) listeyi, bir sonlandırma yerine bir ön ek haline getirmek için yükselttik. Sonraki parça

FŒr

FASCII kodlamasının toplam ikili dizesini vererek listeyi ( ) düzleştirir ve çalışma uzunluğu çıkışı ( Œr) kodlar . Yani

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

ve

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

Sonunda her bir öğenin <4 olup olmadığını kontrol ederiz (Neyse ki bu her zaman 0,1 için doğrudur)

<4F

Örneğin

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]

En sonunda

Ạ

Bunlardan herhangi birinin sahte olması durumunda 0 döndürür (bu durumda, 0).

Kod Sayfaları

Jelly'in kod sayfasında bu kod 20 bayttır ancak 27 kural ihlaline neden olur. UTF-8’de 28 bayttır, ancak yalnızca 14 ihlale maruz kalmaktadır.

— Walpen
kaynak

3

05AB1E , 22 + 3 * 10 = 52

Jonathan Allan'ın Jelly cevabından delta numarası ödünç aldığı 2 penaltıdan kurtarıldı

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

Çevrimiçi deneyin!

açıklama

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

Kodun ikili gösterimi

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

vy¦}Her ikili dizideki ilk baytı kesmek için kullanılan 3 penaltı koşusu , ancak daha kısa bir süre içinde alacağımız 4 harften daha ucuz €¦.

— Emigna
kaynak

@JonathanAllan: Sonunda biraz bahsettim (ama detaylı olarak değil), fakat ne yazık ki €CP-1252'deki ikili gösterimi 10000000tek başına 4'lük bir ceza alan budur.

— Emigna

Ah, öyle mi? ... ve temsili almak için Python kodum # coding: cp1252en üste koyduğumda hatalıydı > _ <

— Jonathan Allan

3

Perl , 33 + 160 = 193

-nBayrak için 32 bayt kod + 1 bayt .

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

(girişin son satır olmadan girilmesi gerekir. Çevrimiçi deneyin bağlantısının -lyeni satırları kaldırmak için üzerinde bayrağı vardır , ancak tek bir giriş için gerekli değildir).

Çevrimiçi deneyin!

xxd dökümü:

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+

Birkaç not:

(.)\1\1\1Birkaç cezalar üzerinde kaydeder (.)\1{3}, 1111|0{4}ya da başka bir regex I (kullanarak düşünebildiğim 0veya {}ağır bir maliyetle geliyor).
printkullanarak üzerinde ~ 8 puan kazandırır -pve $_=çünkü p4 koşmak içeriyor 0ise nyok.
+regex için sınırlayıcı kaydeder olarak bir çalışma 1olduğunu içindedir /.
İki adım yerine sahip birini yaparak !~iki çalışır kaydeder ( ~olan 01111110ikilik sistemde).
unpack"B*" oldukça pahalı (4 koşu), fakat daha ucuz bulamadım ord daha da pahalı olacak).

— Dada
kaynak

3

PHP, 98 + 270 = 368 bayt

Titus'un önerdiklerinden farklı bir yaklaşım almak istedim ve biraz daha uzun, ancak daha az cezalı bir programla sona erdi.

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

çıktılar 1Gerçekliğin , yanlışlık için hiçbir şey yok.

Burada dene!

İkili kodlanmış:

0010010001110110001111010111010101101110011100000110000101100011011010110010100
0001001110100100000101010001001110010110000100100011000010111001001100111011101
1001011011001100010101110100101001001110110010010001100101001111010110001001100
0010111001101100101010111110110001101101111011011100111011001100101011100100111
0100001010000010010001110110010110110011000101011101001011000011000100110110001
0110000110010001010010011101101100101011000110110100001101111001000010111001101
1101000111001001101001011100110111010001110010001010000010010001100101001011000
0100111001100000011000000110000001100000010011100101001001001100010011000100001
0111001101110100011100100110100101110011011101000111001000101000001001000110010
1001011000010011100110001001100010011000100110001001001110010100100111011

(22 olay 0000ve 5 olay 1111, dolayısıyla 270 bayt ceza)

— Roberto06
kaynak

2

PHP, 86 bayt + 370 = 456

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

İkili dizeyi oluşturur ve çizgileri algılamak için bir regex kullanır. Çıktı 1truthy içindir; sahtekarlık için boş.

İle koş echo '<string>' | php -nR '<code>'.

ince ayarlar

backreferences 3 bayt için 100 ceza kazandırır. (-97 puan)

terkedilmiş fikirler

join(array_map(str_split())) 31 bayta ve 90 penaltıya mal olacak
ve <?=/ $argv[1]yerine echo/$argn maliyet başka bir 2 + 40.
str_pad(decbin()) daha pahalı sprintf : 7 bayt ve 110 penaltı.
strtr 13 fazladan bayt için 80 ceza kazandırır, ancak geri referanslar daha iyidir.
Referansların gruplandırılması #(.)\\1{3} 3 bayttan tasarruf sağlar, ancak 10 ceza ekler.
foreach 3 + 50'dir.
Değişken isimlerinde kaydetme mümkün değildir.
çıkış tamponlama 42 + 120'dir.

— Titus
kaynak

Bir ekleme §de for(§;için -9.

— Christoph

2

MATL, 16 bayt + 60 = 76 bayt

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

MATL Online'da deneyin

— Suever
kaynak

2

JavaScript (ES8), 91 bayt + 430 penaltı = 521 toplam

Çıktısı verir 1için trueve 0için false.

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

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000010110110010111000101110001011100111001101011101001011100110110101100001011100000010100001100011001111010011111001100011001011100110001101101000011000010111001001000011011011110110010001100101010000010111010000101000001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110000011000010110010001010011011101000110000101110010011101000010100000110011001010110011010100101100001100010010110100110001001010010010100100101110011010100110111101101001011011100010100000100010001000100010100100101001

Dene

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

Parçacığı genişlet

— kaba tüylü
kaynak

padStartES6’da değil.

— Neil

Lanet olsun! Ne zaman kullansam ES8'e değiştirmeyi unutuyorum (ES7 ve aynı Array.includes()) - teşekkürler, @ Neil.

— Shaggy

1

CJam , 23 bayt

Jonathan Allan'ın deltalarla çalışma fikrini kullanır .

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

Çevrimiçi deneyin!

İkili gösterim:

00110001011100010011001000110101
00110110011000100011001001100010
00110010011001010111011100111010
00111010001011010101101101010100
01010100010101000101110100100011
001010010110011100101101

Açıklama:

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
kaynak

1

Pyth, 19 + 12 * 10 = 139

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

İkili

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

açıklama

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

1

JavaScript, 173 + 89 * 10 = 1063

JavaScript, dizeleri ikiliye dönüştürmede iyi değildir, ancak bu mücadeleye sadece eğlence için bir şans vereceğimi düşündüm.

Kod:

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}

İkili:

0110011001110101011011100110001101110100011010010110111101101110001010000110111000101001011110110110001000111101001000100010001000111011011001100110111101110010001010000111011001100001011100100010000001110100001111010011000000111011011101000011110001101110001011100110110001100101011011100110011101110100011010000011101101110100001010110010101100101001011000110011110101011011011011100010111001100011011010000110000101110010010000110110111101100100011001010100000101110100001010000111010000101001001011100111010001101111010100110111010001110010011010010110111001100111001010000011001000101001010111010010110001100011001011100111010101101110011100110110100001101001011001100111010000101000010000010111001001110010011000010111100100101000001110000010110101100011010110110011000001011101001011100110110001100101011011100110011101110100011010000010101100110001001010010010111001101010011011110110100101101110001010000011000000101001001010010010110001100010001010110011110101100011001011100110101001101111011010010110111000101000001000100010001000101001001110110111001001100101011101000111010101110010011011100010000001100010001011100110110101100001011101000110001101101000001010000010111101011011001100010101110101111011001101000010110001111101011111000101101100110000010111010111101100110100001011000111110100101111011001110010100100111111001000010011000100111010001000010011000001111101

Açıklama:

Çalışmak için bir dize oluşturun:

b="";

Dizedeki her karakterin üzerinde dolaş:

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

Bir dizi oluşturun ve karakter kodunu kullanarak dizeyi ikiliye dönüştürün:

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

Baştaki sıfırları diziye ekleyin:

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

Diziye tekrar bir dizgeye katılın:

b+=c.join("")

Normal bir ifade kullanarak ikili sonuçta dört ya da daha fazla 1 ya da 0'dan oluşan bir dize bulunup bulunmadığını döndürün:

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

Keman:

https://jsfiddle.net/vrtLh97c/

İstatistikleri:

Süre: 173 bytes Ceza: 890 Toplam: 1063

Code Golf zor :)

— StephenRios
kaynak

Kodunuzun ikili gösterimini sağlayabilir ve cezaları belgeleyebilir misiniz?

— Pavel

Bu toplamda 1063 puan almak için 890'lık ceza aldı.

— Pavel

Orijinal gönderiye toplamlar eklendi.

— StephenRios

1

Birkaç yerde kullanmak 1-1yerine 0bazı şeylerden kurtulabilirsiniz.

— Poke

1

Pyth, 21 + 2 * 10 = 41

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

Çevrimiçi deneyin!

İkili gösterim:

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
kaynak

1

Retina, 101 + 1390 = 1491

Kod yazdırılamaz karakterler içeriyor, ancak yayını düzenlerseniz Chrome'da görünüyorlar. -olduğunu \x01-\x7f.

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

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

Çevrimiçi deneyin

Bu kod kullanan buord ikili dönüşüm ve dört dizi ile üstüste gelen için basit bir kontrol ile belirlenebilir.

İkili olarak:

11000010101101100000101011000010101100010000101001010011010111110110000000001010001001010010100001010011011000001100001010110001000010100111101100110010011000000000101000100100011000000000101001111101010101000011000000110001011000000000000100101101011111110110000001011111011011110000101000101001010011010111001101100000001011100000101000101110001010110000101000100100001010100000101000101011011000000010100000110001001010110010100100000001000010100010010001111011001100010111110100110000000010100011000000110001000010100011000100001010011011010010101101100000010111100010100000111111001000010010111001111011001110000111110100101001000010100011000000001010001100000111101100111000011111010111110011000010101101100000101000001010010011010010011001100000001010000010111000101001000000010111101100110011011111010000101000110000

Bu Python programında cezalar sayıldı .

— mbomb007
kaynak

Lütfen yazdırılamayan bir içerdiğinden, bir hexdump ve ikili gösterimi sağlayın.

— Pavel

Basılmayacakların ne / nerede olduğunu, ikili dizgeyi basabilecek bir program sağlayarak (en alttaki çizgiyi belirten) dedim.

— mbomb007

Tamam, o zaman ..

— Pavel

1

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

Çıkış, çıkış kodu aracılığıyladır; 0 gerçek değil, 1 sahte. STDOUT ve STDERR'e çöp üretimi yapar.

Çevrimiçi deneyin!

İkili dökümü

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
kaynak

Bunu 0dahil etmek oldukça kötü buldum . Kullanımı daha iyi1-1

— Poke

@Poke Ben sadece hatamı fark ettim. Sonuç kullanılmadı, bu yüzden neden 0ilk seçtiğimden emin değilim .

— Dennis,

1

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

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

İkili olarak:

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000011100110010111001110010011001010111000001101100011000010110001101100101001010000010111101011011010111000101001101011100011100110101110100101111011001110010110001100011001111010011111000101000001100100011010100110110001010110110001100101110011000110110100001100001011100100100001101101111011001000110010101000001011101000010100000101001001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110011011011000110100101100011011001010010100000110001001010010010100100101001

Cezasının Üzeri yarısı oldukça aşağıdaki karakterleri koşular yerine, bayt arasında örtüşme sıfırlara aşağı: =>//pa//=>aCoAo.

Yana /ler ( 00101111) Ben denedim penaltı) geçiş ödeme testiçin matchgeçiş b) replaceiçin mapama skor her zaman daha yüksek sona erdi. Ancak bunun [\S\s]bir gelişme olduğunu öğrendim [^]. Düzenleme: @Shaggy sayesinde genel olarak 9 bayt kaydedildi.

— Neil
kaynak

Bence |karakter sınıfının orada olmaması gerekiyordu

— ETHproductions

@ETHproductions Açıklamamda doğru anladım ...

— Neil

Toplamı 468 !ile değiştirerek cezanızı 10 tıraş edebilirsiniz 1-. Ayrıca , toplam 463 [\S\s]ile değiştirerek 5 byte daha fazla tasarruf edebilirsiniz..

— Shaggy

@Shaggy Teşekkürler, newlines basılabilir olarak sayılıp sayılmadığından emin değilim, bu yüzden şimdilik güvenli oynayacağım.

— Neil

Js çok satırlı bir regex bayrağını destekliyor mu? Öyleyse, Shaggy'nin önerisini kabul edebilir ve baytları kaydetmek için bayrağı ekleyebilirsiniz.

— Pavel,

1

Pyth , 16 + 1 x 10 = 26 bayt

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

Çevrimiçi deneyin!

İkili

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

püf nokta

Demerits önlemek için aşağıdaki değişiklikler yapılır:

Kullanmak qZ(sıfıra eşit) yerine !(olumsuzlamak)
Kullanma :xy0yerine (aramak) }xy(alt liste olduğu)
Kullanmak yerine Z(değişken, varsayılan olarak sıfır) 0(sıfırın kendisi)

İyileştirmeler

Cezayı atlatmanın bir yolunu bulamıyorum. İkili ile ilgili şu komutları sahibiz:

.Bikili ( 00101110 01[0000]10)
Ccharcode ( 01[0000]11)
.Osekizli ( 00101110 0100[1111])
.Honaltılık ( 00101110 01001[000)

.HBunun bize bir ceza vereceğini de unutmayın , çünkü yazdırılabilir her karakterin başından itibaren ikili gösterimi vardır 0. Bu nedenle, en doğrudan olanı kullandım, bu .Bonu doğrudan ikiliye dönüştürmek.

.HCezadan kaçınmak için son verebilirim ama bu bana 27 byte eder.

nesil

İzin verilmeyen tüm karakterleri, bunların içermediği 0000veya olmayan 1111ve bitmeyen karakterleri buldum 000(çünkü bir sonraki karakterin başlaması gerekir 0):

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

İşte biten karakterler 1000. Sadece sonunda kullanılabilirler:

(8HXhx

— Sızdıran Rahibe
kaynak

4 bitin bağlantısını kesin

Test Kılıfları

kurallar

Liderler Sıralaması

Jöle , 18 bayt + 0 penaltı = 18

Nasıl?

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

İkili

Eski parça değiştirme çözümü 141 bayt + 10 * 101 = 1,151

İkili

APL (Dyalog Klasik) , 26 + 1 × 10 = 36 bayt

notlar

boyun eğme

İkili kaynak

açıklama

Walk-yoluyla

Jelly 28 + 140 görevliler = 168

açıklama

Kod Sayfaları

05AB1E , 22 + 3 * 10 = 52

Perl , 33 + 160 = 193

PHP, 98 + 270 = 368 bayt

PHP, 86 bayt + 370 = 456

MATL, 16 bayt + 60 = 76 bayt

JavaScript (ES8), 91 bayt + 430 penaltı = 521 toplam

Dene

CJam , 23 bayt

Pyth, 19 + 12 * 10 = 139

İkili

açıklama

JavaScript, 173 + 89 * 10 = 1063

Kod:

İkili:

Açıklama:

Keman:

İstatistikleri:

Pyth, 21 + 2 * 10 = 41

Retina, 101 + 1390 = 1491

Python 2,74 (uzunluk) + 130 (ceza) = 204

İkili dökümü

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

Pyth , 16 + 1 x 10 = 26 bayt

İkili

püf nokta

İyileştirmeler

nesil