1에서 9까지의 숫자 목록이 주어지면 각 숫자가 하나의 연속 된 블록으로 함께 그룹화되는지 여부를 출력합니다. 즉, 동일한 숫자 중 두 개가 다른 숫자로 구분되지 않습니다. 숫자가 전혀 나타나지 않으면 괜찮습니다. 가장 적은 바이트가 이깁니다.

입력 : 1에서 9까지의 비어 있지 않은 숫자 목록입니다. 이것은 10 진수, 문자열, 목록 또는 이와 유사한 순서 일 수 있습니다.

출력 : 모든 숫자가 연속 된 블록으로 그룹화 된 경우 일관된 Truthy 값, 그렇지 않은 경우 일관된 Falsey 값.

실제 사례 :

3
51
44999911
123456789
222222222222222222222

틀린 경우 :

818
8884443334
4545
554553
1234567891

var QUESTION_ID=77608,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/77608/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}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>

파이썬 3, 38 34 33 바이트

lambda s:s==sorted(s,key=s.index)

이것은 숫자 목록 또는 단일 문자열을 인수로 예상합니다. Ideone에서 테스트하십시오 .

4 바이트로 골프를 치는 @xsot에게 감사합니다!

1 바이트로 골프를 해준 @immibis에게 감사드립니다!

자바 스크립트 (ES6), 27 바이트

s=>!/(.)(?!\1).*\1/.test(s)

네거티브 lookahead를 사용하여 두 개의 연속되지 않은 숫자를 찾습니다. 그러한 숫자가 두 개 이상 있으면 첫 번째 숫자가 다른 숫자 앞에 오도록 선택할 수 있습니다.

05AB1E , 4 바이트

암호:

Ô¹ÙQ

설명:

Ô     # Push connected uniquified input. E.g. 111223345565 would give 1234565.
 ¹    # Push input again.
  Ù   # Uniquify the input. E.g. 111223345565 would give 123456.
   Q  # Check if equal, which yields 1 or 0.

CP-1252 인코딩을 사용합니다 .

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

젤리 , 5 바이트

ĠIFPỊ

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

작동 원리

ĠIFPỊ  Main link. Input: n (list of digits or integer)

Ġ      Group the indices of n by their corresponding values, in ascending order.
       For 8884443334, this yields [[7, 8, 9], [4, 5, 6, 10], [1, 2, 3]].
 I     Increments; compute the all differences of consecutive numbers.
       For 8884443334, this yields [[1, 1], [1, 1, 4], [1, 1]].
  F    Flatten the resulting 2D list of increments.
   P   Product; multiply all increments.
    Ị  Insignificant; check if the product's absolute value is 1 or smaller.

Pyth, 6 5 바이트

FryAmTheEggman 덕분에 1 바이트

SIxLQ

Python 솔루션 에서 영감을 얻었 습니다 .

테스트 스위트

설명:

SIxLQ
  xLQ   Map each element in the input to its index in the input. Input is implicit.
SI      Check whether this list is sorted.

R, 66 48 46 43 38 바이트

function(s)!any(duplicated(rle(s)$v))

입력을 숫자로 구성된 벡터로 받아들이고 부울을 반환하는 함수입니다. 호출하려면 변수에 지정하십시오.

가장 짧지는 않지만 재미있는 접근법이라고 생각했습니다. 우리는 length 인코딩 입력을 실행하고 값을 추출합니다. 값 목록에 중복이 포함되어 있으면를 반환하고 FALSE, 그렇지 않으면를 반환 TRUE합니다.

모든 테스트 사례를 온라인으로 확인

MickyT 덕분에 20 바이트, Albert Masclans 덕분에 3 바이트, mnel 덕분에 5 바이트 절약!

MATL , 8 바이트

t!=tXSP=

출력은 진리에 대한 것만 포함하는 배열이거나 거짓에 대한 하나 이상의 0을 포함하는 배열입니다.

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

설명

22331조건을 만족 하는 input을 고려하십시오 . 각 문자가 서로 같은지 테스트하면 2D 배열이 제공됩니다.

1 1 0 0 0
1 1 0 0 0
0 0 1 1 0
0 0 1 1 0
0 0 0 0 1

해당 배열의 행 (원자로 간주 됨)이 (사전 적) 내림차순 이면 최종 결과는 진실해야합니다 . 비교를 위해 입력 22321은 배열을 제공합니다

1 1 0 1 0
1 1 0 1 0
0 0 1 0 0
1 1 0 1 0
0 0 0 0 1

행이 정렬되지 않은

t!   % Take string input. Duplicate and tranpose
=    % Test for equality, element-wise with broadcast: gives a 2D array that
     % contains 0 or 1, for all pairs of characters in the input
t    % Duplicate
XS   % Sort rows (as atomic) in increasing order
P    % Flip vertically to obtain decreasing order
=    % Test for equality, element-wise

레티 나 , 17 바이트

M`(.)(?!\1).+\1
0

온라인으로 사용해보십시오!(모든 테스트 사례를 한 번에 실행하도록 약간 수정했습니다.)

첫 번째 정규 표현식은 숫자와 일치 하는 우리가 얻을 수 있도록, 다른 자리로 구분을 0사이에 어디 유효한 입력과 1과 9(유효하지 않은 입력에 의한 상기의 탐욕에 .+, 우리는보다 더 얻을 수 n-1에 대한 일치n 다른 숫자에 ).

결과의 truthiness을 반전하기 위해, 우리는의 수를 계산 0이다의, 1유효 입력과 0잘못된 것들에 대한합니다.

자바, 161 156 바이트

자바 때문에 ...

배열과 수학 조작 으로이 작업을 시도하기 시작했기 때문에이 대답 에서 정규 표현식을 빌리는 것을 부끄럽게 도용 했습니다.

import java.util.regex.*;public class a{public static void main(String[] a){System.out.println(!Pattern.compile("(.)(?!\\1).*\\1").matcher(a[0]).find());}}

언 골프 드 :

import java.util.regex.*;

public class a {
    public static void main(String[] args) {
        System.out.println(!Pattern.compile("(.)(?!\\1).*\\1").matcher(args[0]).find());
    }

현명한 Java 사람처럼 배치하십시오.

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class  {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("(.)(?!\\1).*\\1");
        Matcher m = p.matcher(args[0]);
        System.out.println(!m.find());
    }
}

Pyth, 7 바이트

{IeMrz8

테스트 스위트 .

루비, 23 바이트

익명의 기능. 문자열을 받아들입니다. 정규식 전략.

->n{/(.)(?!\1).*\1/!~n}

정규식 분석

/(.)(?!\1).*\1/
 (.)            # Match a character and save it to group 1
    (?!\1)      # Negative lookahead, match if next character isn't
                #  the same character from group 1
          .*    # Any number of matches
            \1  # The same sequence as group 1

!~문자열 내에 정규식과 일치하는 것이 없으면 return을 반환 true하고 그렇지 않으면 return을 의미 false합니다.

Mathematica, 26 바이트

0<##&@@Sort[#&@@@Split@#]&

MATL, 13 11 바이트

u"G@=fd2<vA

2 바이트를 절약 한 Luis Mendo 에게 감사 합니다!

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

설명

        % Grab the input implicitly
u       % Find the unique characters
"       % For each of the unique characters
    G   % Grab the input again
    @=  % Determine which chars equal the current char
    f   % Find the locations of these characters
    d   % Compute the difference between the locations
    2<  % Find all index differences < 2 (indicating consecutive chars)
    v   % Vertically concatenate all stack contents
    A   % Ensure that they are all true
        % Implicit end of the for loop

하스켈, 44 바이트

import Data.List 
((==)<*>nub).map head.group

사용 예 : ((==)<*>nub).map head.group $ "44999911"-> True.

포인트없는 버전 :

f x = q == nub q                -- True if q equals q with duplicates removed
  where
  q = map head $ group x        -- group identical digits and take the first
                                -- e.g. "44999911" -> ["44","9999","11"] -> "491"
                                -- e.g  "3443311" -> ["3","44","33","11"] -> "3431"

J, 8 바이트

-:]/:i.~

J.js로 테스트하십시오 .

작동 원리

-:]/:i.~  Monadic verb. Argument: y (list of digits)

     i.~  Find the index in y of each d in y.
  ]/:     Sort y by the indices.
-:        Match; compare the reordering with the original y.

파이썬, 56 55 바이트

a=lambda s:~(s[0]in s.lstrip(s[0]))&a(s[1:])if s else 1

C #, 119 바이트

bool m(String s){for(int i=0;i<9;i++){if(new Regex(i.ToString()+"+").Matches(s).Count>1){return false;}}return true;}

언 골프

bool m(String s) {
    for(int i=0;i<9;i++) {
        if(new Regex(i.ToString() + "+").Matches(s).Count > 1) {
            return false;
        }
    }

    return true;
}

줄리아, 35 바이트

s->issorted(s,by=x->findfirst(s,x))

어떤 이유로 든 sort문자열을 가져 가지 않지만 issorted...

요소, 22 바이트

[ dup natural-sort = ]

깡통에 말한 것을 수행합니다. 익명 함수로서, 당신은 call이것을 해야 합니다 : word ;.

루아, 107 94 85 바이트

@LeakyNun 덕분에 13 바이트 절약

적어도 Java : D를 능가합니다. 루아는 문자열 조작에 짜증이 있지만 충분하다고 생각합니다. :).

이 명령어 인자로의 입력을 받아, 출력한다 1truthy 경우 및 falsefalsy들에 대한. 이제 종료 코드를 사용하여 출력합니다. 진실을 나타내는 종료 코드 0, 거짓을 나타내는 1

o=os.exit;(...):gsub("(.)(.+)%1",function(a,b)if 0<#b:gsub(a,"")then o(1)end end)o(0)

언 골프

주의하십시오.라는 두 개의 매직 변수 ...가 있습니다. 첫 번째는 프로그램의 인수를 포함하고 두 번째는 익명 함수에 로컬이며 매개 변수를 포함합니다

o=os.exit;               -- ; mandatory, else it would exit instantly
(...):gsub("(.)(.+)%1",  -- iterate over each group of the form x.*x and apply an anonymous
  function(a,b)          -- function that takes the captured group as parameters
  if 0<#b:gsub(a,"")     -- if the captured group (.+) contain other character than
  then                   -- the one captured by (.)
    o(1)                 -- exit with falsy
  end
end)
o(0)                     -- exit with truthy, reached only when the string is okay

자바 스크립트 ES6, 71 69 바이트

h=y=>y.match(/(.)\1*/g);x=>h((u=h(x)).sort().join``).length==u.length

또는 동등하게 :

x=>((u=x.match(r=/(.)\1*/g)).sort().join``).match(r).length==u.length
x=>(h=y=>y.match(/(.)\1*/g))((u=h(x)).sort().join``).length==u.length

골프가 진행 중입니다.

테스트 사례 확인

var truthy = `3
51
44999911
123456789
222222222222222222222`.split `
`;
var falsey = `818
8884443334
4545
554553
1234567891`.split `
`;

var Q = x => ((u = x.match(r = /(.)\1*/g)).sort().join ``).match(r).length == u.length;
truthy.concat(falsey).forEach(e => {
  t = document.createTextNode(`${e} => ${Q(e)}`);
  o.appendChild(t);
  o.appendChild(document.createElement("br"));
});

* {
  font-family: Consolas, monospace;
}

<div id=o></div>

C # 111 바이트

bool f(string s){for(int i=0;i<s.Length-1;i++)if(s[i]!=s[i+1]&&s.LastIndexOf(s[i])!=i)return 1==2;return true;}

오래된 전략 131 바이트

bool s(string i){var f=Regex.Matches(i,@"([0-9])\1{0,}").Cast<Match>().Select(m=>m.Value[0]);return f.Distinct().SequenceEqual(f);}

첫 골프는 내가 좋아했다고 생각

C, 74 73 71 바이트

면도 한 @xsot 세 바이트 감사합니다!

a[99],c,m;main(d){for(;~c;m|=c^d&&a[d=c]++)c=getchar();putchar(48+!m);}

하스켈, 37 바이트

f l=(==)=<<scanl1 min$(<$>l).(==)<$>l

Luis Mendo의 MATL 답변 과 동일한 방법을 사용합니다 . 각 항목에 대해 동일한 벡터를 생성하고 결과가 내림차순으로 정렬되어 있는지 확인합니다.

(<$>l).(==)<$>l의 짧은 버전입니다 [map(==a)l|a<-l]. 함수 (<$>l).(==)걸리는 a데 map(==a)l에 매핑되고l .

scanl1 min의 가장 작은 누적 요소를 가져옵니다.이 요소 는 반대로 정렬 된 l경우에만 원본과 같습니다 l.(==)=<<이 작업에서 목록이 실제로 변하지 않는지 확인합니다.

다른 재귀 전략은 40 바이트를 제공했습니다.

f(a:b:t)=f(b:t)>(elem a t&&a/=b)
f _=1>0

이렇게하면 첫 번째 요소가 나머지 블록에없는 경우를 제외하고 첫 번째 요소가 나머지 요소에 나타나지 않는지 확인하기 위해 각 접미사를 확인합니다.

라켓, 53 바이트

바보 같은 간단한 버전.

(λ(s)(let([s(string->list s)])(eq?(sort s char<?)s)))

언 골프 드 :

(define (lame-all-together s)
  (let ([s (string->list s)])
    (eq? (sort s char<?) s)))

라켓, 86 바이트

다음 은 더 효율적인 방법에 대한 @xnor의 의견을 구현하는 버전 입니다.

(λ(s)(let([s(string->list(regexp-replace#px"(.)\\1+"s"\\1"))])(eq?(sort s char<?)s)))

언 골프 드 :

(define (all-together s)
    (let ([s (string->list (regexp-replace #px"(.)\\1+" s "\\1"))])
      (eq? (sort s char<?) s )))

자, 이것은 실제로 계산 가중치를 sort함수 에서로 바뀔 수 regexp-replace있지만 흥미로운 해결책이었습니다. 기본적으로 중복 문자의 런을 먼저 제거한 다음 ( 여기 참조 ) 나머지 length-1 런이 정렬 된 방식인지 테스트합니다.

펄 5, 20 바이트

-pe대신 19를 더한 1 입니다 -e.

$_=!/(.)(?!\1).+\1/

Wolfram Language (Mathematica) , 18 바이트

Gather@#==Split@#&

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

Gather동일한 요소의 하위 목록으로 목록을 수집하고 Split연속 된 동일한 요소의 하위 목록으로 목록을 분할합니다. 각 값이 하나의 인접한 블록에만 나타나는 경우에만 동일한 결과를 제공합니다.

볼록, 17 바이트

9´\f{\s'++\ð½¬}ª!

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

Japt , 9 바이트

ò¦ mÌ
eUâ

시도 해봐

설명

          :Implicit input of string U             :e.g., "8884443334"
ò¦        :Split on inequality                    :["888","444","333","4"]
   mÌ     :Map and return the last digit of each  :["8","4","3","4"]
\n        :Assign to U
  Uâ      :Remove duplicates                      :["8","4","3"]
e         :Test for equality with U               :false
          :Implicit output of result

APL (Dyalog) , 17 바이트

(⍋≡⍳∘≢)∘⌽∘∊2⊥∘.=⍨

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