부울 목록에서 가장 긴 참을 찾습니다. 다른 모든 사실을 위조하여 동일한 목록을 반환하십시오.

입출력

목록; 일반적인 형식 (예 : 문자열로 구분 된 목록)

세부

True와 False는 해당 언어가 일반적으로 해당 값 또는 정수 1과 0에 사용하는 모든 것이 될 수 있습니다. 단일 문자를 사용하는 경우 목록은 연결 (예 :) 일 수 있습니다 10001.

가장 긴 달리기를위한 동점이 있다면, 모든 묶는 달리기를 진실로 유지하고 더 짧은 달리기를 위조하십시오.

예

input ↦ output
1,0,1,0,1 ↦ 1,0,1,0,1
1,1,0,1,1,0,1 ↦ 1,1,0,1,1,0,0
1,1,0,1,1,1,0,1,1 ↦ 0,0,0,1,1,1,0,0,0
1,1,1 ↦ 1,1,1
0,0,1 ↦ 0,0,1
0,0 ↦ 0,0
1,1,1,0,0,0,1,1,1,1,0,1,0,0,1,1,0,1,1,1,1,0,0,1,0 ↦ 0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0

( https://stackoverflow.com/q/37447114 에서 직접 )

젤리 , 8 바이트

ṣ0¬¬M¦j0

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

ṣ0¬¬M¦j0  Main link. Argument: A (list of Booleans)

ṣ0        Split at zeroes. This leaves a 2D list of ones.
  ¬       Negate each 1, replacing it with 0.
     ¦    Conditional application:
    M       Yield all maximal indices.
            In lexicographical list comparison, a shorter list of zeroes is less
            than a longer one, so this identifies the longest runs.
   ¬        Negate the items in those lists, changing zeroes back to ones.
      j0  Join, separating by single zeroes.

하스켈, 59 , 58 , 55 , 64 바이트

import Data.List
((=<<)=<<(=<<)(<$).(==).maximum.([1<2]:)).group

재미있는 점은이 곳의 모든 값 목록에서 작동합니다 falsy < truthy. 그래서 False/True, 0/1,'f'/'t' , 등

노트 :

여러 사람이 ( 및를 포함 @proud haskeller하여 @nimi) 지적한 것처럼 이전 버전은 모든 잘못된 값 목록에서 실패했습니다. 의 추가 .([1<2]:)로이 제안한대로이 문제가 해결되었습니다 @proud haskeller. 나는 설명이 여전히 타당하다고 생각하기 때문에 지금은 설명을 동일하게 남겨두고 있습니다. 편집에 대한 설명을 요청하는 사람이 있다면 편집하겠습니다.

설명:

먼저을 빼고 설탕을 제거 group하고 다시 넣습니다. 첫째, 나는 종종 단어보다 기호가 눈에 더 쉽다는 것을 알기 때문에 몇 가지 대체를 할 것입니다. ( =<<'고급'이므로 목록과 함수에 다르게 적용됩니다. 함수 bind의 버전을 호출 하고 =<<있습니다.)

bind :: (a -> b -> c) -> (b -> a) -> b -> c
bind k f = k =<< f
bind k f = \ r -> k (f r) r

f = ((=<<)=<<(=<<)(<$).(==).maximum)
f = ((bind) concatMap (bind)(<$).equals.maximum)
f = (bind concatMap (bind (<$) . equals . maximum))
f = bind concatMap ((bind (<$)) . equals . maximum))
f = bind concatMap ((\f r -> (<$) (f r) r) . equals . maximum))
f = bind concatMap ((\f r -> (f r) <$ r) . equals . maximum)
f = bind concatMap ((\g r -> (g r) <$ r) . equals . maximum)
f = (\h r -> concatMap (h r) r) ((\g r -> (g r) <$ r) . equals . maximum)
f = \r -> concatMap (((\g r -> (g r) <$ r) . equals . maximum) r) r
f = \r -> concatMap (((\g r -> (g r) <$ r) . equals) (maximum r)) r
f = \r -> concatMap (((\g s -> (g s) <$ s)) (equals (maximum r))) r
f = \r -> concatMap (((\s -> ((equals (maximum r)) s) <$ s))) r
f = \r -> concatMap (\s -> (s == (maximum r)) <$ s) r

f . group = ((=<<)=<<(=<<)(<$).(==).maximum).group
f . group = \r -> concatMap (\s -> (s == (maximum (group r))) <$ s) (group r)

마지막 세부 사항은이 x <$ list의 모든 요소 대체 list와를 x하고 group list분할 list동일한 요소의 덩어리로 최대. 그래서 group [1, 1, 2, 3, 3, 3] == [[1, 1], [2], [3, 3, 3]].

요약하면이 함수는 값 목록을 true로만 그룹화하고 false로만 그룹화합니다. 그런 다음 각 그룹에 대해 각 요소를 명령문의 결과로 바꾸고 this is the biggest group(가장 큰 그룹이 true가장 클 것) 그룹을 연결하십시오.

4 바이트 절약 @Zgarb

망막, 47 43 36

0
!
T`p`0`\b(1+)\b(?<=(?=.*1\1).*)|!

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 시도하십시오

골프 4 바이트를위한 msh210 덕분에!

7 바이트 동안 Martin에게도 감사합니다!

설명:

0
!

모든을 0s로 교체하십시오 !. 이 매칭 그룹 있도록하기위한 것입니다 1지금처럼의 짧은 1!및 !1단어 경계 (것 \b또한 하나의 시작이나 문자열의 끝과 일치 그들 사이).

T`p`0`

이것은 백틱 후 정규 표현식을 입력에 적용한 후 모든 일치에서 모든 인쇄 가능한 ASCII 문자를 문자로 변환한다는 구성 옵션 0입니다.

\b(1+)\b(?<=(?=.*1\1).*)|!

이 정규식 1은 0으로 둘러싸인 s 그룹과 일치 하지만 1문자열의 어느 곳에서나 뒤에 오는 문자와 일치 할 수 없습니다 . 위조 될 최대 그룹이 아닙니다. 또한 이것은 !문자를 다시 0s 로 변환하기 위해 추가 한 문자 와 일치합니다 .

MATL, 14 바이트

Y'yy*X>y=b*wY"

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

모든 테스트 사례가 포함 된 수정 된 버전

설명

        % Implicitly grab the input as an array
Y'      % Perform run-length encoding of the input. Yields an array of values and an array
        % of run-lengths
yy      % Copy these outputs
*       % Multiply the values (booleans) by the run-lengths. This will zero-out all
        % zero-valued runs so we don't consider them when computing the longest run.
X>      % Compute the longest run of 1's
y       % Copy the run lengths vector
=       % Determine which runs are the same length as the longest run of ones
b*      % Bubble-up the values from the run-length encoding and multiply element-wise
        % With this boolean. This substitutes all 1's that are not in the longest run
        % of ones with 0's
w       % Flip the run-lengths and values on the stack
Y"      % Perform run-length decoding using these substituted values
        % Implicitly display the resulting boolean

파이썬 2, 62 바이트

lambda s:'0'.join(`1-(t+'1'in s)`*len(t)for t in s.split('0'))

Ideone에서 테스트하십시오 .

작동 원리

s.split('0')입력 문자열을 분할 이야 제로의 실행 이상으로 1 의

각 런 t 에 대해 st+'1' 의 하위 문자열 인지 확인합니다 .

• 이 경우, 실행이 최대 아니라, t+'1'in s반환 사실을 , 1-(t+'1'in s)반환 진정한 = 0 1 - 및 실행이의 실행으로 대체 0 '같은 길이의이야.

• 그렇지 않은 경우, 실행은 최대가된다 t+'1'in s반환 거짓이 , 1-(t+'1'in s)반환 거짓 = 1-1 과 실행이의 실행으로 대체 한 그 자체로, 즉 '같은 길이의이야.

마지막으로, '0'.join제거 된 모든 0을 복원합니다 .

J, 25 바이트

[:(}.=>./)@;0<@(*#);.1@,]

이것은 0-1 배열을 받아서 돌려주는 모나 딕 동사입니다. 다음과 같이 사용하십시오.

   f =: [:(}.=>./)@;0<@(*#);.1@,]
   f 1 1 0 1 1 1 0 1 1
0 0 0 1 1 1 0 0 0

설명

[:(}.=>./)@;0<@(*#);.1@,]  Input is y.
            0          ,]  Prepend 0 to y, and
                   ;.1@    cut the result along occurrences of 0,
                           so that each piece begins with a 0.
               (*#)        Multiply each piece element-wise by its length,
             <@            and put it in a box.
                           Without the boxing, the pieces would go in a 0-padded array.
           ;               Join the pieces back together.
                           Now all runs of 1 have been replaced by runs of (1+length of run).
[:(      )@                Apply verb in parentheses:
   }.                        remove the prepended 0,
     =                       form the 0-1 array of equality with
      >./                    the maximum value.

Pyth, 26 24 23 21 바이트

M,G&HGJrgMrQ8 9qReSJJ

테스트 스위트.

• 사용 1/0하거나 true/false입력합니다.
• true/false출력에 사용 합니다.

설명

M,G&HGJrgMrQ8 9qReSJJ

           Q      input
          r 8     run-length encode
        gM        convert each run of 1 to their length
                  for example: [1,1,1,0,1,1] will be
                  converted to [3,3,3,0,2,2]
                  in the run-length encoded version
                  [1,1,1,0,1,1] will be [[3,1],[1,0],[2,1]]
                  [3,3,3,0,2,2] will be [[3,3],[1,0],[2,2]]
                  therefore basically [G,H] becomes [G,H and G]
                  which is what the code below does:
M,G&HG            def g(G,H): return [G,H and G]
       r      9   run-length decode
      J           store to J

               qReSJJ

                R   J   in each element of J
               q eSJ    check if equal to maximum of J

이전 23 바이트

M,G&HGJrgMrQ8 9msqdeSJJ

테스트 스위트.

• 사용 1/0하거나 true/false입력합니다.
• 1/0출력에 사용 합니다.

이전 24 바이트

Jrm,hd&edhdrQ8 9msqdeSJJ

테스트 스위트.

• 사용 1/0하거나 true/false입력합니다.
• 1/0출력에 사용 합니다.

이전 26 바이트

rm?nhdeS.u&YhNQ0,hd0drQ8 9

테스트 스위트.

• 사용 1/0하거나 true/false입력합니다.
• 1/0출력에 사용 합니다.

Oracle SQL 12.1, 137135 바이트

SELECT REPLACE(REPLACE(REPLACE(:1,m,2),1,0),2,m)FROM(SELECT MAX(TRIM(COLUMN_VALUE))m FROM XMLTABLE(('"'||REPLACE(:1,0,'",0,"')||'"')));

언 골프

-- Replace the max value with 2
-- Then replace every 1 with 0
-- Then replace 2 with the max value
SELECT REPLACE(REPLACE(REPLACE(:1,m,2),1,0),2,m)
FROM   ( -- Split on 0 and keep the max value
         SELECT MAX(TRIM(COLUMN_VALUE))m 
         FROM XMLTABLE(('"'||REPLACE(:1,'0','",0,"')||'"'))
       );

단일 문자를 사용하십시오. 예 : '1100111'

수학 , 46 41

1-Join@@Sign[1~Max~#-#]&[#*Tr/@#]&@*Split

0및의 목록에서 작동합니다 1. 나는 다른 답변을 볼 때까지 꽤 잘했다고 생각했습니다!

46 자 버전 설명; 더 개선 할 수 없을 때 업데이트합니다.

이 코드에 대한 설명이 요청되었습니다.
코드 골프가 아닌 해당 (버전 10 연산자 양식 사용)은 다음과 같습니다.

RightComposition[
  Split,
  Map[# Tr@# &],
  # - Max[1, #] &,
  UnitStep,
  Apply[Join]
]

이는 5 단계 (하위 기능)로 구성된 기능이 위에서 아래로 순서대로 적용됨을 의미합니다.

• Split: 동일한 요소로 실행됩니다 : {1,1,0,1,1,0,1} ↦ {{1,1}, {0}, {1,1}, {0,0}}

• Map[# Tr@# &]: 각 하위 목록 ( Map) #에 대해 합계 (벡터 추적, Tr)를 곱한 값 ( ) : {1,1} ↦ {2, 2}

• # - Max[1, #] &모든 요소에서 목록 목록의 어느 곳에 나 나타나는 최대 값을 빼거나 더 높은 값을 뺍니다. (하나는 모두 0의 경우를 처리합니다.)

• UnitStep: x <0의 경우 0과 같고 x> = 0의 경우 1이며 모든 요소에 적용됩니다.

• Apply[Join]: 하위 목록을 단일 목록으로 결합합니다. Flatten또는 로 수행 할 수도 Catenate있지만 짧은 형태 Join@@로 더 간결합니다.

C, 135 129 바이트

온라인 시도

m,c,i,d,j;f(int*l,int s){while(i<s)c=l[i++]?c+1:0,m=c>m?c:m;while(j<s)if(l[j++])d=d+1;else if(d<m)while(d)l[j-1-d--]=0;else d=0;}

언 골프

m,c,i;
f(int*l,int s)
{
    // obtain max
    while(i<s)
        c = l[i++] ? c+1 : 0,
        m = c>m ? c : m;

    c=0,i=0;

    // remove smaller segments
    while(i<s)
        if(l[i++]) c=c+1;
        else if(c<m) while(c) l[(i-1)-c--]=0;
        else c=0;
}

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

s=>s.replace(/1+/g,t=>t.replace(/1/g,+!~s.indexOf(t+1)))

1을 더 길게 실행하기 위해 문자열을 검색하여 측정 한 바와 같이 (길이가 가장 긴) 실행하지 않는 한 1의 모든 런을 확인하고 문자를 0으로 대체하여 작동합니다.

이전 72 바이트 재귀 솔루션 :

f=s=>/11/.test(s)?f(s.replace(/1(1*)/g,"0$1")).replace(/0(1+)/g,"1$1"):s

1의 런이없는 경우 (즉, 최대 1 개의 런) 아무 것도 수행하지 않습니다. 그렇지 않으면, 1각각 1또는 하나의 런 에서 하나 를 빼고 더 짧은 런에서 재귀 적으로 호출 한 다음 1(현재 가장 긴) 런에 다시 씁니다. 재귀 호출 수는 가장 긴 실행 길이보다 1이 적습니다.

줄리아, 51 바이트

s->replace(s,r"1+",t->map(c->c-contains(s,"1"t),t))

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

작동 원리

replace입력 문자열에서 하나 이상의 1을 모두 실행 합니다. 의 정규식을 통해 r"1+"및 람다 호출 t->map(c->c-contains(s,"1"t),t)대체 문자열을 결정합니다.

람다 c->c-contains(s,"1"t)는 런의 모든 문자를 매핑 합니다. t .

• 경우 "1"t(연결이)의 서브 스트링 들 , 실행은 최대 아니다 contains반환 사실 과 c-contains(s,"1"t)반환 진정한 = '0'- '1'로 모두 교체 1 '과 그 실행에이야 0 S'이 (가) 있습니다.

• 경우 "1"t(연결이)의 하위 아닙니다 의 , 실행은 최대이며, contains반환 거짓 과 c-contains(s,"1"t)반환 거짓 = '1'- '1' , 수정되지 않은 실행을 떠나.

APL, 22 자

(⊣=⌈/)∊(⊣×+/¨)(~⊂⊣)0,⎕

영어로 (블록에서 오른쪽에서 왼쪽으로) :

• 입력에 0을 추가
• 각 0으로 시작하는 상자
• 각 상자에 합계를 곱하십시오
• 반음 낮추다
• 숫자가 최대 값과 같으면 1, 그렇지 않으면 0

자바 8, 205 바이트

이것은 다음에 대한 람다 식입니다 Function<String,String>.

s->{int x=s.length();for(String t="1",f="0";s.indexOf(t+1)>=0;t+=1){s=s.replaceAll(0+t+0,0+f+0);if(s.indexOf(t+0)==0)s=s.replaceFirst(t,f);if(s.lastIndexOf(0+t)==--x-1)s=s.substring(0,x)+f;f+=0;}return s;}

입력 / 출력은 String true가 1로 표시되고 false가 0으로 표시되는 위치입니다. 값을 구분하는 구분 문자는 없습니다.

설명이있는 코드 :

inputString -> {
  int x = inputString.length();
  //starting with the truth combination "1",
  //loop until the input string does not contain the combination appended with another "1"
  //with each consecutive loop appending a "1" to the combination
  for( String truthCombo = "1", falseCombo = "0"; inputString.indexOf( truthCombo + 1 ) >= 0; truthCombo += 1 ) {
    //all instances in the input string 
    //where the combination has a "0" on either side of it
    //are replaced by "0"'s
    inputString = inputString.replaceAll( 0 + truthCombo + 0, 0 + falseCombo + 0 );
    //if the combination followed by a "0"
    //is found at the beginning of the input string
    //replace it with "0"'s
    if( inputString.indexOf( truthCombo + 0 ) == 0 )
      inputString = inputString.replaceFirst( truthCombo , falseCombo );
    //if the combination preceeded by a "0"
    //is found at the end of the input string
    //replace it with "0"'s
    if( inputString.lastIndexOf( 0 + truthCombo ) == --x - 1 )
      inputString = inputString.substring( 0, x ) + falseCombo;
    falseCombo += 0;
  }
  return inputString;
}

테스트 사례에 대한 아이디어 를 참조하십시오

클로저, 137 바이트

#(let[v(map(juxt first count)(partition-by #{1}%))](mapcat(fn[t](repeat(t 1)(if(=[1(apply max(map(fn[[f c]](if(= 1 f)c 0))v))]t)1 0)))v))

먼저 입력을 연속적인 0과 1로 분할하고 이들을 분할의 첫 번째 요소와 요소 수의 "튜플"에 매핑합니다. 그런 다음 이것이 1의 최대 길이 시퀀스인지 아닌지에 따라 필요한 수의 0 또는 1을 반복합니다.

덜 골프 :

(def f #(let [v(map(juxt first count)(partition-by #{1}%))
              m(apply max(map(fn[[f c]](if(= 1 f)c 0))v))]
           (mapcat (fn[[f c]](repeat c(if(=[1 m][f c])1 0))) v)))

펄 5, 68 바이트

67 -pe대신에 1을 더한 것-e

y/0/ /;$_<${[sort@a]}[-1]&&y/1/0/for@a=split/\b/;$_=join"",@a;y; ;0

0과 1의 문자열 (연결)을 예상하고 인쇄합니다.