ค้นหาความจริงที่ยาวนานที่สุดในรายการบูลีน ส่งคืนรายการเดียวกันพร้อมกับความจริงอื่น ๆ ทั้งหมดที่เท็จ

อินพุตเอาต์พุต

รายการ; รูปแบบปกติใด ๆ (เช่นรายการที่คั่นด้วยสตริง)

รายละเอียด

จริงและเท็จสามารถเป็นอะไรก็ได้ที่ภาษาของคุณมักใช้สำหรับค่าเหล่านั้นหรือจำนวนเต็ม 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.

Haskell, 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ตอนนี้ฉันกำลังทิ้งคำอธิบายไว้เหมือนเดิมเพราะฉันคิดว่ามันยังสมเหตุสมผล หากใครแสดงความคิดเห็นโดยขอคำอธิบายการแก้ไขฉันจะแก้ไข

คำอธิบาย:

ฉันจะ desugar ครั้งแรกโดยไม่ต้องgroupแล้วเพิ่มกลับ ก่อนอื่นฉันพบว่าคำพูดมักจะง่ายต่อสายตามากกว่าสัญลักษณ์ดังนั้นฉันจะทำการทดแทนสองสามครั้ง (โปรดทราบว่า=<<เป็น 'classy' ดังนั้นจึงใช้กับรายการและฟังก์ชันต่างกันฉันกำลังเรียก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]]ดังนั้น

เพื่อสรุปผลทั้งหมดฟังก์ชั่นจะแยกรายการค่าเป็นกลุ่มของจริงเท่านั้นและกลุ่มของเท็จเท่านั้น จากนั้นสำหรับแต่ละกลุ่มให้แทนที่แต่ละองค์ประกอบด้วยผลลัพธ์ของคำสั่งthis is the biggest group(กลุ่มที่ใหญ่ที่สุดของtrueจะเป็นกลุ่มที่ใหญ่ที่สุด) และเชื่อมกลุ่มเข้าด้วยกัน

สี่ไบต์บันทึกโดย @Zgarb

จอประสาทตา 47 43 36

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

ลองออนไลน์! หรือลองทุกกรณีทดสอบ

ขอบคุณ msh210 สำหรับการเล่นกอล์ฟ 4 ไบต์!

ขอบคุณมากสำหรับมาร์ตินเป็นเวลา 7 ไบต์!

คำอธิบาย:

0
!

แทนที่ทั้งหมด0ด้วย!s สิ่งนี้ทำเพื่อให้กลุ่มการจับคู่ของ1s สั้นลงขณะนี้1!และ!1จะมีขอบเขตคำ ( \b) ระหว่างพวกเขาซึ่งตรงกับการเริ่มต้นหรือจุดสิ้นสุดของสตริง

T`p`0`

นี่คือตัวเลือกการกำหนดค่าที่บอกว่าหลังจากใช้ regex หลังจาก backtick ไปยังอินพุตในทุกการแข่งขันจะแปลอักขระ ASCII ที่พิมพ์ได้ทุกตัวเป็น0อักขระ

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

regex นี้ตรงกับกลุ่มของ1s ที่ล้อมรอบด้วยศูนย์ แต่ไม่สามารถจับคู่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

Python 2, 62 ไบต์

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

ทดสอบบนIdeone

มันทำงานอย่างไร

s.split('0')แยกสายป้อนsเข้าไปวิ่งศูนย์หรือมากกว่า1 's

สำหรับการทำงานในแต่ละทีเราตรวจสอบว่าt+'1'เป็นย่อยของs

• ถ้ามันเป็นวิ่งไม่ได้สูงสุดt+'1'in sกลับทรู , 1-(t+'1'in s)กลับ1 - ทรู = 0และเรียกใช้จะถูกแทนที่ด้วยการทำงานของ0 's ความยาวเดียวกัน

• ถ้ามันไม่ได้วิ่งเป็นสูงสุดt+'1'in sผลตอบแทนเท็จ , 1-(t+'1'in s)กลับ1 - เท็จ = 1และเรียกใช้จะถูกแทนที่ด้วยการทำงานของ1 's ความยาวเดียวกันคือด้วยตัวเอง

ในที่สุดการ'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, 137 135 ไบต์

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'

Mathematica , 46 41

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

ผลงานในรายการของและ0 1ฉันคิดว่าฉันทำได้ดีมากจนกระทั่งฉันดูคำตอบอื่น ๆ !

คำอธิบายสำหรับเวอร์ชั่นตัวอักษร 46 ตัว ฉันจะอัปเดตเมื่อฉันไม่สามารถปรับปรุงได้อีก

ขอคำอธิบายของรหัสนี้
ค่าที่ไม่ใช่โค้ด - กอล์ฟ (ใช้แบบฟอร์มผู้ประกอบการรุ่น 10) คือ:

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

นี่หมายถึงฟังก์ชั่นที่ประกอบด้วยห้าขั้นตอน (ฟังก์ชั่นย่อย) ที่ใช้ตามลำดับจากบนลงล่าง

• Split: แยกออกเป็นองค์ประกอบที่เหมือนกัน: 1,1,0,1,1,1,0,1} ↦ {{1,1}, {0}, {1,1}, {0,0}}

• Map[# Tr@# &]: สำหรับแต่ละรายการย่อย ( Map) คูณมัน ( #) ด้วยผลรวม (การติดตามเวกเตอร์Tr): {1,1} ↦ {2, 2}

• # - Max[1, #] &ลบออกจากทุกองค์ประกอบค่าสูงสุดที่ปรากฏที่ใดก็ได้ในรายการหรืออย่างใดอย่างหนึ่งที่สูงกว่า (ตัวจัดการกรณีของศูนย์ทั้งหมด)

• UnitStep: เท่ากับ 0 สำหรับ x <0 และ 1 สำหรับ x> = 0 ใช้กับทุกองค์ประกอบ

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

Ungolfed

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 ไบต์

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

ทำงานโดยการตรวจสอบการทำงานทั้งหมดของ 1s และแทนที่อักขระด้วย 0 เว้นแต่ว่าการรันนั้นยาวที่สุด (เท่ากัน) ที่วัดได้โดยการค้นหาสตริงเพื่อการทำงานที่ยาวขึ้นของ 1s

โซลูชันแบบเรียกซ้ำ 72- ไบต์ก่อนหน้า:

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

ไม่ทำอะไรเลยหากไม่มีการรัน 1s (เช่น 1s สูงสุด) มิฉะนั้นลบหนึ่ง1จากแต่ละ1หรือเรียกใช้จากนั้นเรียกตัวเองซ้ำในการทำงานสั้นลงแล้วเพิ่มหนึ่ง1กลับมาทำงาน (ตอนนี้ยาวที่สุดเท่ากัน) จำนวนการเรียกซ้ำแบบเรียกซ้ำจะน้อยกว่าความยาวของการเรียกใช้ที่ยาวที่สุด

จูเลีย 51 ไบต์

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

ลองออนไลน์!

มันทำงานอย่างไร

replaceพบทั้งหมดวิ่งทั้งหมดของหนึ่งหรือมากกว่า1 's ในการป้อนข้อมูลสตริงsผ่าน regex ไม่r"1+"และเรียกร้องแลมบ์ดาt->map(c->c-contains(s,"1"t),t)เพื่อตรวจสอบสตริงทดแทน

แลมบ์ดาแผนที่c->c-contains(s,"1"t)ตัวละครทั้งหมดในการทำงานของคนเสื้อ

• ถ้า"1"t(concatenation) เป็นย่อยของsวิ่งไม่ได้สูงสุดcontainsผลตอบแทนที่แท้จริงและc-contains(s,"1"t)ผลตอบแทน'1' - = true '0'เปลี่ยนทุก1 's ในระยะที่มี0 ' s

• ถ้า"1"t(concatenation) ไม่ใช่ซับสตริงของsการรันคือ maximal containsส่งคืนfalseและc-contains(s,"1"t)ส่งคืน'1' - false = '1'ทำให้ไม่มีการเรียกใช้ที่ไม่ได้แก้ไข

APL, 22 ตัวอักษร

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

ในภาษาอังกฤษ (จากขวาไปซ้ายในบล็อก):

• เสริม 0 ให้กับอินพุต
• กล่องเริ่มต้นด้วยแต่ละ 0
• คูณแต่ละกล่องด้วยผลรวมของมัน
• เรียบ
• 1 ถ้าจำนวนเท่ากับจำนวนสูงสุดเป็น 0 มิฉะนั้น

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

ดูideoneสำหรับกรณีทดสอบ

Clojure, 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))

พาร์ติชันแรกป้อนข้อมูลเข้าเป็นศูนย์และต่อเนื่องและแมปเหล่านี้เป็น "tuples" ขององค์ประกอบแรกของพาร์ติชันและจำนวนองค์ประกอบ จากนั้นจะทำซ้ำจำนวนศูนย์หรือจำนวนที่ต้องการขึ้นอยู่กับว่านี่เป็นลำดับความยาวสูงสุดของคนหรือไม่

หักกอล์ฟ:

(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 ไบต์

67, บวก 1 -peแทน-e

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

คาดหวังและพิมพ์สตริง (การต่อข้อมูล) 0s และ 1s