Tìm chuỗi chạy dài nhất của true trong danh sách các booleans. Trả về cùng một danh sách, với tất cả các dấu vết khác bị làm sai lệch.

Đầu ra đầu vào

Một danh sách; bất kỳ định dạng thông thường nào (ví dụ: danh sách được phân tách dưới dạng chuỗi).

Chi tiết

Đúng và sai có thể là bất cứ thứ gì ngôn ngữ của bạn thường sử dụng cho các giá trị đó hoặc các số nguyên 1 và 0. Nếu bạn sử dụng các ký tự đơn, danh sách có thể là một cách ghép (ví dụ 10001:).

Nếu có một sự ràng buộc cho lần chạy dài nhất, hãy giữ tất cả các lần chạy đúng và làm sai lệch tất cả các lần chạy ngắn hơn.

Ví dụ

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

(trực tiếp từ https://stackoverflow.com/q/37447114 )

Thạch , 8 byte

ṣ0¬¬M¦j0

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

ṣ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.

Haskell, 59 , 58 , 55 , 64 byte

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

Lưu ý thú vị, điều này hoạt động trên bất kỳ danh sách các giá trị trong đó falsy < truthy. Vì vậy False/True, 0/1, 'f'/'t'vv

Chú thích:

Như một số người đã chỉ ra (bao gồm @proud haskellervà @nimi), phiên bản trước đã thất bại trong danh sách tất cả các giá trị giả. Việc bổ sung .([1<2]:)đã sửa lỗi này, theo đề xuất của @proud haskeller. Bây giờ tôi đang để lại lời giải thích tương tự, vì tôi nghĩ nó vẫn có ý nghĩa. Nếu bất cứ ai có ý kiến, yêu cầu giải thích về chỉnh sửa, tôi sẽ chỉnh sửa.

Giải trình:

Trước tiên tôi sẽ không có group, và sau đó thêm lại. Đầu tiên, tôi thấy rằng các từ thường dễ nhìn hơn các ký hiệu, vì vậy tôi sẽ thực hiện một vài thay thế. (Lưu ý rằng =<<'đẳng cấp' vì vậy nó áp dụng khác nhau cho danh sách và chức năng. Tôi đang gọi bindphiên bản của =<<chức năng.)

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)

Các chi tiết cuối cùng là x <$ listthay thế mọi phần tử của listvới xvà group listchia phần listthành các phần tử bằng nhau. Vì vậy group [1, 1, 2, 3, 3, 3] == [[1, 1], [2], [3, 3, 3]].

Để tổng hợp tất cả, hàm chia danh sách các giá trị thành các nhóm chỉ đúng và các nhóm chỉ sai. Sau đó, đối với mỗi nhóm, thay thế từng phần tử bằng kết quả của câu lệnh this is the biggest group(nhóm lớn nhất truesẽ là lớn nhất) và ghép các nhóm.

Bốn byte được lưu bởi @Zgarb

Võng mạc, 47 43 36

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

Hãy thử trực tuyến! hoặc thử tất cả các trường hợp thử nghiệm

Cảm ơn msh210 vì đã chơi golf 4 byte!

Cũng rất cảm ơn Martin cho 7 byte!

Giải trình:

0
!

Thay thế tất cả 0bằng !s. Điều này được thực hiện để làm cho các nhóm so khớp 1ngắn hơn, như bây giờ 1!và !1sẽ có một ranh giới từ ( \b) giữa chúng, cũng khớp với phần đầu hoặc phần cuối của chuỗi.

T`p`0`

Đây là một tùy chọn cấu hình nói rằng sau khi áp dụng regex sau khi backtick vào đầu vào, trong mọi trận đấu sẽ dịch mọi ký tự ascii có thể in thành một 0ký tự.

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

Regex này khớp với các nhóm 1được bao quanh bởi các số 0, nhưng không thể khớp với một chuỗi 1theo sau bởi chính nó ở bất cứ đâu trong chuỗi. Đây là những nhóm không tối đa sẽ bị làm sai lệch. Ngoài ra, điều này cũng phù hợp với các !ký tự chúng tôi đã thêm để chuyển đổi chúng thành 0s.

MATL, 14 byte

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

Hãy thử trực tuyến!

Phiên bản sửa đổi với tất cả các trường hợp thử nghiệm

Giải trình

        % 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

Python 2, 62 byte

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

Kiểm tra nó trên Ideone .

Làm thế nào nó hoạt động

s.split('0')chia tách chuỗi đầu vào là vào chạy của zero hoặc nhiều hơn 1 's

Đối với mỗi lần chạy t , chúng tôi kiểm tra xem có phải t+'1'là một chuỗi con của s không .

• Nếu đúng như vậy, lần chạy không tối đa, t+'1'in strả về True , 1-(t+'1'in s)trả về 1 - True = 0 và lần chạy được thay thế bằng một lần chạy 0 có cùng độ dài.

• Nếu nó không phải là, thời gian là tối đa, t+'1'in strở lại False , 1-(t+'1'in s)trở lại 1 - False = 1 và chạy được thay thế bằng một hoạt động của 1 's chiều dài tương tự, ví dụ, bằng cách riêng của mình.

Cuối cùng, '0'.joinkhôi phục tất cả 0 's.

J, 25 byte

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

Đây là một động từ đơn âm lấy và trả về mảng 0-1. Sử dụng nó như thế này:

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

Giải trình

[:(}.=>./)@;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 byte

M,G&HGJrgMrQ8 9qReSJJ

Bộ thử nghiệm.

• Sử dụng 1/0hoặc true/falsetrong đầu vào.
• Sử dụng true/falsetrong đầu ra.

Giải trình

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 byte trước

M,G&HGJrgMrQ8 9msqdeSJJ

Bộ thử nghiệm.

• Sử dụng 1/0hoặc true/falsetrong đầu vào.
• Sử dụng 1/0trong đầu ra.

24 byte trước

Jrm,hd&edhdrQ8 9msqdeSJJ

Bộ thử nghiệm.

• Sử dụng 1/0hoặc true/falsetrong đầu vào.
• Sử dụng 1/0trong đầu ra.

26 byte trước

rm?nhdeS.u&YhNQ0,hd0drQ8 9

Bộ thử nghiệm.

• Sử dụng 1/0hoặc true/falsetrong đầu vào.
• Sử dụng 1/0trong đầu ra.

Oracle SQL 12.1, 137 135 byte

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

Không chơi gôn

-- 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,"')||'"'))
       );

Đầu vào sử dụng các ký tự đơn. Vd: '1100111'

Toán học , 46 41

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

Hoạt động trên danh sách 0và 1. Tôi nghĩ rằng tôi đã làm khá tốt cho đến khi tôi nhìn vào các câu trả lời khác!

Giải thích cho phiên bản 46 ký tự; Tôi sẽ cập nhật khi tôi không thể cải thiện nó hơn nữa.

Một lời giải thích về mã này đã được yêu cầu.
Tương đương với mã không phải là mã (sử dụng biểu mẫu toán tử phiên bản 10) là:

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

Điều này có nghĩa là một chức năng gồm năm bước (chức năng phụ) được áp dụng theo thứ tự từ trên xuống dưới.

• Split: chia thành các phần tử giống hệt nhau: {1,1,0,1,1,0,1} ↦ {{1,1}, {0}, {1,1}, {0,0}}

• Map[# Tr@# &]: Với mỗi danh sách con ( Map) nhân nó ( #) với tổng của nó (theo dõi vectơ, Tr): {1,1} ↦ {2, 2}

• # - Max[1, #] &trừ đi mọi yếu tố, giá trị tối đa xuất hiện ở bất kỳ đâu trong danh sách danh sách, hoặc một, tùy theo giá trị nào cao hơn. (Người xử lý trường hợp của tất cả các số không.)

• UnitStep: bằng 0 cho x <0 và 1 cho x> = 0, áp dụng cho mọi phần tử.

• Apply[Join]: tham gia các danh sách phụ vào một danh sách. Cũng có thể được thực hiện với Flattenhoặc Catenate, nhưng ở dạng ngắn Join@@thì ngắn gọn hơn.

C, 135 129 byte

Thử trực tuyến

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;}

Bị đánh cắp

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;
}

JavaScript (ES6), 56 byte

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

Hoạt động bằng cách kiểm tra tất cả các lần chạy 1 giây và thay thế các ký tự bằng 0 trừ khi lần chạy đó dài nhất (bằng nhau), như được đo bằng cách tìm kiếm chuỗi trong thời gian dài hơn 1 giây.

Giải pháp đệ quy 72 byte trước đó:

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

Không có gì nếu không có các lần chạy 1s (tức là nhiều nhất là 1 giây). Mặt khác, trừ một 1từ mỗi 1hoặc chạy của nó, sau đó tự gọi đệ quy trên các lần chạy ngắn hơn, sau đó thêm một lần nữa 1vào các lần chạy (bây giờ dài nhất bằng nhau). Số lượng các cuộc gọi đệ quy ít hơn một lần so với thời lượng của cuộc gọi dài nhất.

Julia, 51 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

replacetìm tất cả các bài chạy của một hoặc nhiều 1 's trong đầu vào chuỗi s qua regex r"1+"và gọi lambda t->map(c->c-contains(s,"1"t),t)để xác định chuỗi thay thế.

Bản đồ lambda c->c-contains(s,"1"t)trên tất cả các nhân vật trong quá trình chạy của những người t .

• Nếu "1"t(nối) là một chuỗi con của s , thì lần chạy không tối đa, containstrả về true và c-contains(s,"1"t)trả về '1' - true = '0' , thay thế tất cả 1 'trong đó chạy bằng 0 's.

• Nếu "1"t(nối) không phải là một chuỗi con của s , thì lần chạy là tối đa, containstrả về false và c-contains(s,"1"t)trả về '1' - false = '1' , khiến cho việc chạy không được sửa đổi.

APL, 22 ký tự

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

Trong tiếng Anh (từ phải sang trái theo khối):

• thêm 0 vào đầu vào
• hộp bắt đầu với mỗi 0
• nhân mỗi hộp với tổng của nó
• làm phẳng
• 1 nếu số bằng giá trị lớn nhất, 0 nếu không

Java 8, 205 byte

Đây là một biểu thức lambda cho một 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;}

đầu vào / đầu ra là một String nơi mà true được biểu thị bằng 1 và false được biểu thị bằng 0. Không có ký tự phân cách nào phân tách các giá trị.

mã với lời giải thích:

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;
}

xem ideone cho các trường hợp thử nghiệm

Clojure, 137 byte

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

Đầu tiên phân vùng đầu vào thành các số 0 liên tiếp và các số 0 và ánh xạ chúng thành "bộ dữ liệu" của phần tử đầu tiên của phân vùng và số lượng phần tử. Sau đó, nó lặp lại số lượng không hoặc số cần thiết, tùy thuộc vào việc đây có phải là chuỗi có độ dài tối đa hay không.

Ít chơi gôn hơn:

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

Perl 5, 68 byte

67, cộng 1 cho -pethay vì-e

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

Mong đợi và in một chuỗi (nối) 0 và 1.