귀하의 작업 : 입력 문자열이 주어지면 해당 문자열의 이진 표현에 4 개 1또는 4 개의 0행이 없는지 여부를 결정하십시오 . 또한 코드 자체에는 이러한 연속 실행이 포함되어서는 안됩니다.

테스트 사례

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

규칙

입력은 항상 공백 문자를 포함하여 인쇄 가능한 ASCII 범위 내에 있습니다.
- 코드는 비트 수준에서만 중요하므로 모든 인코딩을 사용할 수 있습니다.
이 조건으로 인해 공백과 다른 많은 문자를 사용할 수 없으므로 코드 에는 실제로 각 실행에 대해 10 바이트의 벌점으로 행에 4 개의 실행이 포함될 수 있습니다.
- 5 1초 또는 0s 의 런은 2 개의 런으로 계산되고, 6 개의 행은 3 개의 런으로 계산됩니다.
입력은 다른 형식이 아닌 문자열 또는 문자 배열입니다.
완전한 프로그램이나 기능을 작성할 수 있습니다.
답변에 코드의 이진 표현을 제공해야합니다.

행운을 빈다.

이 스크립트 는 챌린지에 도움이되고, 코드를 입력에 넣고 UTF-8을 사용하는 경우 코드의 이진 표현, 길이, 페널티 및 총점을 제공합니다.

리더 보드

다음은 일반 리더 보드와 언어 별 수상자 개요를 생성하는 스택 스 니펫입니다.

코드 스 니펫 표시

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

스 니펫 확장

— 파벨
소스

1

나는 스 니펫이 버그가 있음을 확신합니다. 예를 들어 ||나열된 것을 보았습니다 0111110001111100.

— Ørjan Johansen

그래, 좋은 지적이야 일초.

— Pavel

2

과제가 문자열의 점수를 찾는 것이 더 재미 있었을 것입니다.

— Adám

1

@JonathanAllan 글쎄, 내가 의도 한 방식으로, 그러나 더 반영하면 나는 그 이유를 알지 못하므로 바꿀 것입니다.

— Pavel

1

@Pavel 페널티가있는 경우 점수는 바이트만을 기준으로하지 않습니다. 이것은 [code-golf]가 아니라 [code-challenge]가됩니다. 태그 위키에서 : "소스 코드 길이가 기본 점수 기준이 아닌 경우 다른 태그를 대신 사용해보십시오." TL; DR, 실제 점수 = / = 프로그램의 바이트 수이며 가장 짧은 코드가 최고 점수를 얻는 것을 의미하지는 않으므로 [code-golf]가 아닙니다.

— mbomb007

19

젤리 , 18 바이트 + 페널티 = 18

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

ASCII 문자열 입력의 8 비트 단어 표현에 1길이가 4 이상인 동일한 비트 문자열이없는 경우를 반환 합니다 0.

온라인으로 사용해보십시오! (추가 사례가 추가 된 테스트 스위트)

Jelly의 코드 페이지를 사용하면 동일한 비트의 길이가 4 이상인 하위 문자열이 없습니다.

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

동일한 비트 실행 길이 :

221323221211111312322133122121221111213121123132213111122211311332313211313211111112

방법?

단점을 피하기위한 요령은 다음과 같습니다.

"문자를 서수 O로 변환 "모나드 를 79사용하여 숫자 를 문자 로 변환 한 Ọ다음 "입력을 사용하여 젤리 코드 평가"를 수행 v합니다.
일반 2 진법 기본 변환을 사용하는 간단한 2 바이트 대안으로 B( 0x42, 1000010)를 사용하여 이진으로 직접 변환하는 것을 피 b2합니다.
동일한 비트의 런을 계산하기위한 몇 가지 일반적인 선택을 피하기 위해-첫 번째 선택은 "지정된 길이의 모든 겹치는 슬라이스" ṡ( 0xF5또는 11110101)입니다. 두 번째 선택은 "모든 하위 목록" Ẇ( 0xCF또는 11001111)을 사용하는 것입니다.
현재 사용하기 전에 사용했던 해결 방법은 (연속 요소간에) 증분 ( I0과 1을 같은 바닥에 놓음)을 사용하고 행에서 3 개의 0이 발생하는 것을 찾는 것입니다. 내가 가진 이항 함수를 사용하여 사람에게 모든 0을 변환 할합니다 2c즉 2CX - 제작 -1될 s의 0s를 1의가 될 2들과 0의가 될1에스; 방법이있는 코드는 하위 목록의 첫 번째 항목도 찾아보실 수 있습니다 [1,1,1]로 w111.
그러나 더 짧은 방법은 "주어진 길이의 모든 겹치는 슬라이스"의 동작을 모방하기 위해 명백해졌으며, 약간의 다이어 드와 함께 4 방향 겹치는 감소를 ṡ사용할 수 있습니다 . 이 값을 더해서 수행 하면 s를 계산 하므로 임의의 값 또는 존재하는 값은 진솔한 값을 반환하는 지표입니다. 여기서의 문제는 다음의 명백한 단계는 상기 모듈을 수행하는 것 인 4 올리기 위해 그을 하고 (다른 가능한 값 남기고 동등한 항목 , 및 )을 변경하지만 갖는다<dyad>4\+4\10404123+\%4\%내부 비트 값 010,111 갖는 0000 이 저하 방지하기 위해 숫자 100100을 모두베이스로 변환 4 와 b4(맵핑 0에 [0], 1행 [1], 2행 [2], 3행 [3]과 4행 [1,0])과 함께 평탄화 전체 목록 F. 이제 마지막 테스트는 단순히 0모나드로 직접 달성 할 수있는 목록에 s 가 있는지 확인하는 것 Ạ입니다.

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?

참고 : 2 가 순서 목록과 연결 되는 이유는 입력 문자열에서 4 의 유일한 실행이 첫 번째 문자의 선행 0에있는 경우를 처리하기위한 것 입니다. 이러한 문자는 다음과 같습니다. tab; 줄 바꿈; 운송비. 이것이 없으면 기본 256 변환은 (완전히 연결된) 이진 문자열에서 선행 0을 효과적으로 제거합니다. 선행 2를 사용 하면 선행 0이 있고 앞에 1과 0이 추가됩니다. 인쇄 가능한 ASCII에는 정확히 3 개의 선행 0이 없으므로 나머지 점검 전에이 추가 비트를 버릴 필요가 없습니다.

— 조나단 앨런
소스

나는 당신이 진실 또는 거짓에 대해 출력 / 반환하는 가치가 일관성 이 있어야한다는 것을 부정하고 그와 비슷한 것을 추가 할 수 있다고 가정 합니다 . 또한 당신의 참 / 거짓은 질문에서 반대입니다.

— Emigna

나는 방금 그것에 대해 물었습니다-처음 읽었을 때 (많은 시간 전에) 나는 "진실하고 허위로 출력 / 반환하는 가치는 일관성이 있어야합니다." 달리기 사이에 같은 방식으로 유지되는 한 어느 방향 으로든 출력 할 수 있다는 의미입니다. 직선 부정은 단점을 초래할 것입니다.

— Jonathan Allan

내가 그렇게 할 필요가 없다면 분명히 일부를 절약 할 수 있습니다. 내가 작업중 인 새 버전으로 점수가 매우 낮습니다. 나는 당신이 올바르게 해석되기를 바랍니다 :)

— Emigna

그럼 난 예제와의 엄격 일치하는 값으로 주위 모두에게 같은 방법을 제공 트릭을 수행하는 두 바이트 접미사를 준 0하고 1필요가있을 경우.

— Jonathan Allan

좋은. 어떻게했는지 기대합니다. 모든 단점을 무시하면 15로

— 줄어 듭니다

12

자바 7 812 726 673 644 634 616 599 588 145 바이트 + 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.*");}

페널티를 최소화하기 위해 공백 대신 줄 바꿈을 사용하고 있습니다 ...

온라인으로 사용해보십시오!

이진

01100010011011110110111101101100011001010110000101101110000010100110001000101000011000110110100001100001011100100101101101011101011000100010100101111011010100110111010001110010011010010110111001100111000010100110011100111101001000100010001000111011011001100110111101110010001010000110001101101000011000010111001000001010011000110011101001100010001010010110011100101011001111010110011100101110011001100110111101110010011011010110000101110100001010000010001000100101001000100010101100101000001100010010110100110001001010010010101100100010001110000110010000100010001011000110111001100101011101110000101001001001011011100111010001100101011001110110010101110010001010000100100101101110011101000110010101100111011001010111001000101110011101000110111101010011011101000111001001101001011011100110011100101000011000110010110000110010001010010010100100101001001110110111001001100101011101000111010101110010011011100010000101100111001011100110110101100001011101000110001101101000011001010111001100101000001000100010111000101010001010000010111000101001010111000101110000110001010111000101110000110001010111000101110000110001001011100010101000100010001010010011101101111101

이전 비트 시프 팅 솔루션 141 바이트 + 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;}

온라인으로 사용해보십시오!

이진

011000100110111101101111011011000110010101100001011011100000101001100010001010000110001101101000011000010111001001011011010111010110001000101001011110110000101001101001011011100111010000001010011011110011110100110000001011000111000000111101001100000010110001101001001110110000101001100110011011110111001000101000011000110110100001100001011100100000101001100011001110100110001000101001011110110110011001101111011100100010100001101001001111010011000000111011011010010011110000111000001110110010100101111011011010010110011000101000001010000110001100100110001010000011000100111100001111000110100100101011001010110010100100101001001111000011000100101001011110110110111100111101001100000011101101110000001010110010101100111011011111010110010101101100011100110110010101111011011100000011110100110000001110110110111100101011001010110011101101111101011010010110011000101000001100110011110001101111011111000011001100111100011100000010100101110010011001010111010001110101011100100110111000001010001101100011110000110101001110110111110101111101011100100110010101110100011101010111001001101110000010100011010100111100001101100011101101111101

— 찌름
소스

줄 바꿈으로 좋은 트릭. 계수 00000/ 111112 실점으로, 000000/ 111111등 I 세 가지로 101 개 실행 합계를 계산합니다.

— ETHproductions

@ETHproductions 수정

— Poke

이것은 자바가 결코 이것을 위해 의도되지 않았기 때문에 이겨야한다

— Christopher

10

APL (Dyalog Classic) , 26 + 1 × 10 = 36 바이트

노트

1로 4 회 실행합니다. ⎕IO←0많은 시스템에서 기본값이 필요합니다 . 이 점에 유의 해야한다 문자열이 문자 당 한 바이트가되도록 클래식 인터프리터에서 실행.

제출

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

온라인으로 사용해보십시오!

이진 소스

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

설명

⍞ 문자열 입력을위한 프롬프트

11 ⎕DR 변환 1 비트 부울 ( 1 ) D ATA R epresentation

⊂ 우리는 그것에 여러 가지를 적용 할 수 있도록 동봉

(… ) ⍷¨ 다음 순서 각각이 시작되는 이진 표시기…

× 부호 (이진 데이터에서는 작동하지 않지만 런을 분할하기위한 스페이서로 포함됨)

4 \¨ 길이를 각각 길이 4로 확장 (복사)

⍳ 최대 정수

≢ 탈리

⍬⍬ 두 개의 빈 숫자 목록으로 구성된 목록

∊ 입대하다

⌈\ 누적 최대

⌽ 역

⊃ 첫 번째를 선택

1 ≠ 다른가? (즉 NOT)

연습

ungolfed un-de-runned 버전에 "48"을 입력합니다 ~ ∨/ ∊ (0 0 0 0)(1 1 1 1) ⍷¨ ⊂ 11 ⎕DR ⍞:

11 ⎕DR ⍞ "48"을 1,011100으로 변환합니다 (즉, Dec 52 56, Hex 34 38)

(0 0 0 0)(1 1 1 1) ⍷¨ ⊂0- 런과 1- 런의 시작을 찾습니다. (0000000000) (000000000)

∨/ ∊진실이 있는지 확인합니다 (즉, 달리기). 1

~그것을 부정한다; 0

— 아담
소스

4

젤리 28 + 140 단점 = 168

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

설명

OB

인수를 이진 인코딩 목록으로 변환합니다. 예 :

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

다음 조각

UÇ€U

B앞의 0을 포함하지 않으므로 위 목록에 문자가 누락 될 수 있다는 사실을 수정합니다 . Ç€각 요소에 대해 이전에 정의 된 링크를 호출하여

L8_0xṭ

이 링크는

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

예를 들어

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

이 작업 전후에 목록을 추가하여 (목록에서 두 번의 U호출) 추가하지 않고 앞에 추가되도록합니다. 다음 조각

FŒr

목록 ( F)을 평평하게하여 ASCII 인코딩의 총 이진 문자열을 제공하고 실행 길이는 출력 ( Œr)을 인코딩합니다 . 예를 들어

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

과

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

마지막으로 우리는 각 요소가 <4인지 확인합니다 (감사하게 이것은 0.1에 대해 항상 참입니다).

<4F

예를 들어

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]

마지막으로

Ạ

거짓 인 경우 0을 반환합니다 (이 경우 0).

코드 페이지

Jelly의 코드 페이지에서이 코드는 20 바이트이지만 27 개의 실행 위반 규칙이 있습니다. UTF-8에서는 28 바이트이지만 14 번의 위반 만 발생합니다.

— 월펜
소스

3

05AB1E , 22 + 3 * 10 = 52

Jonathan Allan의 Jelly 답변 에서 델타 트릭을 빌리는 2 개의 페널티 런을 저장했습니다.

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

온라인으로 사용해보십시오!

설명

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

코드의 이진 표현

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

3 개의 페널티 런은 vy¦}각 이진 문자열에서 첫 번째 바이트를 잘라내는 데 사용되지만, 더 짧은 4 개의 런보다 저렴합니다 €¦.

— 에미 냐
소스

@JonathanAllan : 마지막에 조금 언급했지만 (자세한 것은 아니지만) €CP-1252 의 이진 표현 10000000은 4의 페널티가 발생합니다.

— Emigna

아, 그래! ... 그리고 # coding: cp1252상단에 넣었을 때 표현을 얻는 파이썬 코드가 잘못되었습니다. > _ <

— Jonathan Allan

3

펄 , 33 + 160 = 193

32 바이트의 코드 + -n플래그의 경우 1 바이트

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

(마지막 줄 바꿈없이 입력을 제공해야합니다. 온라인으로 시도 링크에는 줄 바꿈 -l을 제거하기위한 플래그가 있지만 단일 입력의 경우에는 필요하지 않습니다).

온라인으로 사용해보십시오!

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+

몇 가지 참고 사항 :

(.)\1\1\1몇 처벌을 통해 저장 (.)\1{3}, 1111|0{4}또는 어떤 다른 정규식 내가 (사용 생각할 수 0또는 {}무거운 비용에 온다).
print~ 8 포인트를 절약 -p하고 4 를 포함 하지만 그렇지 $_=않기 때문에 p실행 합니다. 0n
+정규식에 대한 구분이 저장으로의 실행 1그에서입니다 /.
두 단계 대신 한 일을 !~2 실점을 절약하는 것은 ( ~이다 01111110진).
unpack"B*"꽤 비싸지 만 (4 회) 저렴하게 찾을 수 없었습니다 (솔루션 기반 ord이 훨씬 비쌉니다).

— 다다이즘
소스

3

PHP, 98 + 270 = 368 바이트

나는 Titus가 제안한 것과는 다른 접근법을 원했고 약간 길지만 덜 처벌적인 프로그램으로 끝났습니다.

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

출력 1truthy를 들어, falsey에 대한 아무것도.

여기에서보십시오!

이진 인코딩 :

0010010001110110001111010111010101101110011100000110000101100011011010110010100
0001001110100100000101010001001110010110000100100011000010111001001100111011101
1001011011001100010101110100101001001110110010010001100101001111010110001001100
0010111001101100101010111110110001101101111011011100111011001100101011100100111
0100001010000010010001110110010110110011000101011101001011000011000100110110001
0110000110010001010010011101101100101011000110110100001101111001000010111001101
1101000111001001101001011100110111010001110010001010000010010001100101001011000
0100111001100000011000000110000001100000010011100101001001001100010011000100001
0111001101110100011100100110100101110011011101000111001000101000001001000110010
1001011000010011100110001001100010011000100110001001001110010100100111011

(22 회 발생 0000및 5 회 발생 1111, 따라서 270 바이트의 페널티)

— roberto06
소스

2

PHP, 86 바이트 + 370 = 456

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

이진 문자열을 만들고 정규 표현식을 사용하여 줄무늬를 감지합니다. 결과는 1진실을위한 것입니다. 허위를 위해 비 웁니다.

로 실행하십시오 echo '<string>' | php -nR '<code>'.

비틀기

역 참조는 3 바이트에 대해 100 개의 페널티를 저장합니다. (-97 점)

버려진 아이디어

join(array_map(str_split())) 31 바이트와 90 페널티
및 <?=/ $argv[1]대신 echo/ $argn비용 또 다른 2 + 40.
str_pad(decbin())sprintf7 바이트 및 110 페널티 보다 비용이 많이 듭니다 .
strtr 13 바이트 추가에 80 점을 절약하지만 역 참조가 더 좋습니다.
역 참조를 그룹화 #(.)\\1{3}하면 3 바이트가 절약되지만 10 개의 페널티가 추가됩니다.
foreach 비용은 3 + 50입니다.
변수 이름을 저장할 수 없습니다.
출력 버퍼링 비용은 42 + 120입니다.

— 디도서
소스

a를 §에 for(§;대한 -9.

— Christoph

2

MATL, 16 바이트 + 60 = 76 바이트

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

MATL Online 에서 사용해보십시오

— 서버
소스

2

자바 스크립트 (ES8), 91 바이트 + 430 벌 = 총 521

이 출력됩니다 1에 대한 true및 0대한 false.

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

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000010110110010111000101110001011100111001101011101001011100110110101100001011100000010100001100011001111010011111001100011001011100110001101101000011000010111001001000011011011110110010001100101010000010111010000101000001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110000011000010110010001010011011101000110000101110010011101000010100000110011001010110011010100101100001100010010110100110001001010010010100100101110011010100110111101101001011011100010100000100010001000100010100100101001

시도 해봐

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

스 니펫 확장

— 얽히고 설킨
소스

padStartES6에 없습니다.

— Neil

젠장! @Neil Array.includes()덕분에 ES7을 사용할 때마다 ES8로 변경하는 것을 잊어 버렸습니다 (ES7 및 동일 ).

— 얽히고 설킨

1

CJam , 23 바이트

사용 조나단 앨런의 아이디어 델타에 대한 작업.

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

온라인으로 사용해보십시오!

이진 표현 :

00110001011100010011001000110101
00110110011000100011001001100010
00110010011001010111011100111010
00111010001011010101101101010100
01010100010101000101110100100011
001010010110011100101101

설명:

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.

— 마틴 엔더
소스

1

Pyth, 19 + 12 * 10 = 139

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

이진

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

설명

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

— 우리엘
소스

1

자바 스크립트, 173 + 89 * 10 = 1063

JavaScript는 문자열을 이진으로 변환하는 데 좋지는 않지만이 도전에 재미를 줄 것이라고 생각했습니다.

암호:

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}

이진 :

0110011001110101011011100110001101110100011010010110111101101110001010000110111000101001011110110110001000111101001000100010001000111011011001100110111101110010001010000111011001100001011100100010000001110100001111010011000000111011011101000011110001101110001011100110110001100101011011100110011101110100011010000011101101110100001010110010101100101001011000110011110101011011011011100010111001100011011010000110000101110010010000110110111101100100011001010100000101110100001010000111010000101001001011100111010001101111010100110111010001110010011010010110111001100111001010000011001000101001010111010010110001100011001011100111010101101110011100110110100001101001011001100111010000101000010000010111001001110010011000010111100100101000001110000010110101100011010110110011000001011101001011100110110001100101011011100110011101110100011010000010101100110001001010010010111001101010011011110110100101101110001010000011000000101001001010010010110001100010001010110011110101100011001011100110101001101111011010010110111000101000001000100010001000101001001110110111001001100101011101000111010101110010011011100010000001100010001011100110110101100001011101000110001101101000001010000010111101011011001100010101110101111011001101000010110001111101011111000101101100110000010111010111101100110100001011000111110100101111011001110010100100111111001000010011000100111010001000010011000001111101

설명:

작업 할 문자열을 작성하십시오.

b="";

문자열의 각 문자를 반복합니다.

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

문자 코드를 사용하여 배열을 만들고 문자열을 이진수로 변환하십시오.

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

배열에 선행 0을 추가하십시오.

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

배열을 다시 문자열로 결합하십시오.

b+=c.join("")

이진 결과에서 정규식을 사용하여 4 개 이상의 1 또는 0의 문자열을 찾았는지 여부를 반환합니다.

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

깡깡이:

https://jsfiddle.net/vrtLh97c/

통계 :

길이 : 173 바이트 페널티 : 890 총계 : 1063

코드 골프는 어렵다 :)

— StephenRios
소스

코드의 이진 표현을 제공하고 처벌을 문서화 할 수 있습니까?

— Pavel

총 점수 1063 점으로 890의 페널티를받습니다.

— Pavel

원래 게시물에 총계를 추가했습니다.

— StephenRios

1

몇몇 장소 1-1대신에 사용 0하면 몇 가지 단점을 줄일 수 있습니다.

— Poke

1

Pyth, 21 + 2 * 10 = 41

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

온라인으로 사용해보십시오!

이진 표현 :

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
소스

1

망막, 101 + 1390 = 1491

코드에 인쇄 할 수없는 문자가 포함되어 있지만 게시물을 수정하면 Chrome에 표시됩니다. -입니다 \x01-\x7f.

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

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

온라인으로 사용해보십시오

이 코드는 이것을ord 사용 하여 바이너리로 변환하고 겹치는 시퀀스 4를 간단하게 검사합니다.

이진으로 :

11000010101101100000101011000010101100010000101001010011010111110110000000001010001001010010100001010011011000001100001010110001000010100111101100110010011000000000101000100100011000000000101001111101010101000011000000110001011000000000000100101101011111110110000001011111011011110000101000101001010011010111001101100000001011100000101000101110001010110000101000100100001010100000101000101011011000000010100000110001001010110010100100000001000010100010010001111011001100010111110100110000000010100011000000110001000010100011000100001010011011010010101101100000010111100010100000111111001000010010111001111011001110000111110100101001000010100011000000001010001100000111101100111000011111010111110011000010101101100000101000001010010011010010011001100000001010000010111000101001000000010111101100110011011111010000101000110000

이 파이썬 프로그램으로 벌칙을 세었다 .

— mbomb007
소스

인쇄 할 수없는 파일이 포함되어 있으므로 16 진 덤프 및 2 진 표현을 제공하십시오.

— Pavel

나는 이미 이진 문자열을 인쇄 할 수있는 프로그램을 제공하는 것과 함께 인쇄 할 수없는 것들이 무엇인지 어디에 있는지 말했다.

— mbomb007

그럼 ..

— Pavel

1

파이썬 2 , 74 (길이) + 130 (벌칙) = 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

출력은 종료 코드를 통해 이루어집니다. 0 은 진실이고 1 은 거짓입니다. STDOUT 및 STDERR에 가비지 출력을 생성합니다.

온라인으로 사용해보십시오!

이진 덤프

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

— 데니스
소스

나는 그것이 0포함하기가 꽤 나쁘다 는 것을 알았습니다 . 사용하는 것이 좋습니다1-1

— Poke

@Poke 방금 실수를 깨달았습니다. 결과는 사용되지 않으므로 0처음에 왜 선택했는지 모르겠습니다 .

— Dennis

1

자바 스크립트 (ES6) 87 88 + 390 380 = 477, 468 바이트

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

이진으로 :

01110011001111010011111000110001001011010010111100101000001011100010100101011100001100010101110000110001010111000011000100101111001011100111010001100101011100110111010000101000011100110010111001110010011001010111000001101100011000010110001101100101001010000010111101011011010111000101001101011100011100110101110100101111011001110010110001100011001111010011111000101000001100100011010100110110001010110110001100101110011000110110100001100001011100100100001101101111011001000110010101000001011101000010100000101001001010010010111001110100011011110101001101110100011100100110100101101110011001110010100000110010001010010010111001110011011011000110100101100011011001010010100000110001001010010010100100101001

패널티의 절반 이상은 다음 문자로 실행되는 것이 아니라 바이트 간 겹침에서 0으로 줄어 듭니다 =>//pa//=>aCoAo.

때문에 /들 ( 00101111) 나는 시도 페널티 킥)에서 전환 지불 test에 match로 전환 B) replace에 map있지만 점수가 항상 높은 결국합니다. 그러나 나는 그것이 [\S\s]개선 된 것을 알았 습니다 [^]. 편집 : @Shaggy 덕분에 전체적으로 9 바이트가 절약되었습니다.

— 닐
소스

나는 |캐릭터 클래스에 있다고 생각 하지 않는다

— ETHproductions

@ETHproductions 내 설명에서 바로 알 수 있습니다 ...

— Neil

!와 함께 1-총 468을 교체하여 페널티를 10으로 줄일 수 있습니다 . 그리고 총 463 으로 교체 [\S\s]하여 5 바이트를 추가로 절약 할 수 있습니다..

— Shaggy

@Shaggy Thanks, 줄 바꿈이 인쇄 가능한 것으로 계산되는지 확실하지 않지만 지금은 안전하게 재생할 것입니다.

— Neil

js는 여러 줄 정규식 플래그를 지원합니까? 그렇다면 Shaggy의 제안을 수락하고 플래그를 추가하여 여전히 바이트를 절약 할 수 있습니다.

— Pavel

1

Pyth , 16 + 1 x 10 = 26 바이트

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

온라인으로 사용해보십시오!

이진

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

트릭

단점을 피하기 위해 다음과 같은 변경이 수행됩니다.

사용하는 qZ대신에 (0 인) !(부정)
사용 :xy0대신에 (검색) }xy(하위 목록입니다)
사용 Z(변수 0으로 기본) 대신에 0(자신을 영)

개량

나는 형벌을 우회 할 방법을 찾지 못한다. 바이너리와 관련된 명령은 다음과 같습니다.

.B이진 ( 00101110 01[0000]10)
C문자 코드 ( 01[0000]11)
.O옥타 리 ( 00101110 0100[1111])
.H16 진수 ( 00101110 01001[000)

참고 .H모든 인쇄 가능한 문자가 이진 표현으로 시작이 있기 때문에 또한, 우리에게 페널티 킥을 줄 것이다 0. 따라서 가장 직접적인 것을 사용했습니다. 즉 직접 .B바이너리로 변환합니다.

.H페널티를 피하기 위해 끝낼 수는 있지만 27 바이트가 소요됩니다 ...

세대

내가 찾을 포함하지 않는 사람들을 모두 허용되는 문자, 0000또는 1111, 그와 함께 끝나지 않는 000(다음 문자로 시작해야하기 때문에 0)

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

로 끝나는 문자는 다음과 같습니다 1000. 그들은 끝에 만 사용할 수 있습니다 :

(8HXhx

— 새는 수녀
소스

4 비트 연결 끊기

테스트 사례

규칙

리더 보드

젤리 , 18 바이트 + 페널티 = 18

방법?

자바 7 812 726 673 644 634 616 599 588 145 바이트 + 10 * 44 = 585

이진

이전 비트 시프 팅 솔루션 141 바이트 + 10 * 101 = 1,151

이진

APL (Dyalog Classic) , 26 + 1 × 10 = 36 바이트

노트

제출

이진 소스

설명

연습

젤리 28 + 140 단점 = 168

설명

코드 페이지

05AB1E , 22 + 3 * 10 = 52

펄 , 33 + 160 = 193

PHP, 98 + 270 = 368 바이트

PHP, 86 바이트 + 370 = 456

MATL, 16 바이트 + 60 = 76 바이트

자바 스크립트 (ES8), 91 바이트 + 430 벌 = 총 521

시도 해봐

CJam , 23 바이트

Pyth, 19 + 12 * 10 = 139

이진

설명

자바 스크립트, 173 + 89 * 10 = 1063

암호:

이진 :

설명:

깡깡이:

통계 :

Pyth, 21 + 2 * 10 = 41

망막, 101 + 1390 = 1491

파이썬 2 , 74 (길이) + 130 (벌칙) = 204

이진 덤프

자바 스크립트 (ES6) 87 88 + 390 380 = 477, 468 바이트

Pyth , 16 + 1 x 10 = 26 바이트

이진

트릭

개량

세대