รับจำนวนเต็มn > 0ส่งออกความยาวของลำดับต่อเนื่องที่ยาวที่สุดของ0หรือ1ในการเป็นตัวแทนไบนารี

ตัวอย่าง

• 6เขียน110ในระบบไบนารี่ ลำดับที่ยาวที่สุดคือ11ดังนั้นเราควรกลับมา2
• 16→การ10000→การ4
• 893→การ1101111101→การ5
• 1337371→การ101000110100000011011→การ6
• 1→การ1→การ1
• 9965546→การ100110000000111111101010→การ7

Python 2 , 46 45 ไบต์

f=lambda n,k=1:`k`in bin(n^n/2)and-~f(n,k*10)

ลองออนไลน์!

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

โดย XORing nและn / 2 (หารด้วย2หลักสับปิดบิตสุดท้าย) เราได้รับจำนวนเต็มใหม่ม.ที่มีบิตล้างระบุการจับคู่บิตติดกันในn

ตัวอย่างเช่นถ้าn = 1337371เรามีดังต่อไปนี้

n    = 1337371 = 101000110100000011011₂
n/2  =  668685 =  10100011010000001101₂
m    = 1989654 = 111100101110000010110₂

สิ่งนี้จะช่วยลดภารกิจในการค้นหาศูนย์ที่ยาวที่สุด ตั้งแต่ฐานเป็นตัวแทนของจำนวนเต็มบวกเสมอเริ่มต้นด้วย1เราจะพยายามที่จะหาที่ยาวที่สุด10 *สตริงของตัวเลขที่ปรากฏในฐานเป็นตัวแทนของม. สามารถทำซ้ำได้

เตรียมkเป็น1 ทุกครั้งที่ฉถูกดำเนินการทดสอบครั้งแรกของเราถ้าแทนทศนิยมของkปรากฏในฐานเป็นตัวแทนของม. ถ้าเป็นเช่นนั้นเราคูณkด้วย10และเรียกfอีกครั้ง ถ้ามันไม่ได้รหัสไปทางขวาของandไม่ได้ดำเนินการและเราจะกลับเท็จ

bin(k)[3:]การทำเช่นนี้ครั้งแรกที่เราคำนวณ ในตัวอย่างของbin(k)ผลตอบแทน'0b111100101110000010110'และที่จุดเริ่มต้นจะถูกลบด้วย0b1[3:]

ตอนนี้-~ก่อนที่จะโทร recursive เพิ่มขึ้นเท็จ / 0ครั้งเดียวสำหรับทุกครั้งฉเรียกว่าซ้ำ เมื่อ10 {J} ( 1ตามด้วยเจซ้ำของ0 ) ไม่ปรากฏอยู่ในฐานเป็นตัวแทนของk , ระยะที่ยาวที่สุดของศูนย์ในkมีความยาวJ - 1 เนื่องจากj - 1ศูนย์ติดต่อกันในkบ่งชี้ว่าjจับคู่บิตที่อยู่ติดกันในnผลลัพธ์ที่ต้องการคือjซึ่งเป็นสิ่งที่เราได้รับโดยการเพิ่มค่าเท็จ / 0รวมjครั้ง

Python 2, 46 ไบต์

f=lambda n,r=1:max(r,n and f(n/2,1+~-n/2%2*r))

ลองออนไลน์

สารสกัดจากตัวเลขไบนารีจากnในสิ่งที่ตรงกันข้ามด้วยซ้ำการและn/2 n%2ติดตามความยาวของการวิ่งในปัจจุบันrของตัวเลขที่เท่ากันโดยการรีเซ็ตเป็น 0 หากตัวเลขสองหลักสุดท้ายไม่เท่ากันจากนั้นเพิ่ม 1

การแสดงออก~-n/2%2เป็นตัวบ่งชี้ว่าตัวเลขสองหลักสุดท้ายมีค่าเท่ากันnคือ 0 หรือ 3 โมดูโล 4 การตรวจสอบตัวเลขสองหลักสุดท้ายปรากฏออกมาสั้นลงกว่าการจดจำตัวเลขก่อนหน้า

05AB1E , 6 ไบต์

b.¡€gM

ลองออนไลน์!

คำอธิบาย

b       # convert to binary
 .¡     # split at difference
   €g   # map length on each
     M  # take max

Mathematica, 38 ไบต์

Max[Length/@Split[#~IntegerDigits~2]]&

หรือ

Max[Tr/@(1^Split[#~IntegerDigits~2])]&

Python ขนาด 53 ไบต์

import re;lambda g:max(map(len,re.findall('1+|0+',bin(g))))

ฟังก์ชั่นแลมบ์ดานิรนาม

เยลลี่ 6 ไบต์

BŒgL€Ṁ

ลองออนไลน์!

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

BŒgL€Ṁ  Main link. Argument: n

B       Binary; convert n to base 2.
 Œg     Group adjacent, identical elements.
   L€   Map length over the groups.
     Ṁ  Take the maximum.

Ruby, 41 40 ไบต์

->b{("%b%b"%[b,~b]).scan(/1+/).max.size}

ค้นหาลำดับที่ยาวที่สุดของ '1' ใน b หรืออินเวอร์ส

ขอบคุณ manatwork สำหรับการบันทึก 1 ไบต์

JavaScript (ES6), 54 ไบต์

f=(n,r=0,l=1,d=2)=>n?f(n>>1,d^n&1?1:++r,r>l?r:l,n&1):l

โซลูชันแบบเรียกซ้ำที่มีการจัดการบิตจำนวนมาก nเก็บอินพุต, rเก็บความยาวของการวิ่งปัจจุบัน, lเก็บความยาวของการวิ่งที่ยาวที่สุด, และdเก็บตัวเลขก่อนหน้า

ตัวอย่างการทดสอบ

f=(n,r=0,l=1,d=2)=>n?f(n>>1,d^n&1?1:++r,r>l?r:l,n&1):l

for(var i of [0,1,2,3,4,5,6,7,8,9,16,893,1337371]) console.log(`f(${i}): ${f(i)}`)

ทับทิม, 51 44 43 ไบต์

ฟังก์ชั่นการแก้ปัญหา

@ Manatwork ทำมาจากเวทย์มนตร์

->s{('%b'%s).scan(/0+|1+/).map(&:size).max}

Python 2, 57 ไบต์

a=lambda n:n and max((n&-n|~n&-~n).bit_length()-1,a(n/2))

โซลูชันแบบเรียกซ้ำ อาจมีรูปแบบที่สั้นกว่าสำหรับเวทย์มนตร์บิต

Perl, 43 ไบต์

#!perl -p
\@a[$a+=$_-1+($_>>=1)&1||-$a]while$_;$_=@a

นับ Shebang เป็นหนึ่งจะถูกนำเข้าจาก stdin

ลองออนไลน์!

Pipขนาด 16 ไบต์

ดูเหมือนว่าจะต้องเป็นวิธีที่สั้นกว่าเพื่อให้ได้ตัวเลขที่เหมือนกัน ...

MX#*(TBa`1+|0+`)

รับอินพุตเป็นอาร์กิวเมนต์บรรทัดคำสั่ง ลองออนไลน์!

คำอธิบาย

     TBa          1st cmdline arg, To Binary
    (   `1+|0+`)  Find all matches of this regex
  #*              Map length operator to that list
MX                Get the maximum and autoprint it

Perl 6 , 36 ไบต์

{(.base(2)~~m:g/1+|0+/)».chars.max}

คำอธิบาย:

{                                 }   # a lambda
  .base(2)                            # convert the argument to base 2
          ~~m:g/     /                # regex match, with global matching turned on
                1+|0+                 # match one or more 1, or one or more 0
 (                    )».chars        # replace each match by its length
                              .max    # take the maximum number

ลองมันออนไลน์

Haskell, 79 ตัวอักษร

maximum.map length.group.i

ที่ไหน

import Data.List
i 0=[]
i n=mod n 2:i(div n 2)

หรือในเวอร์ชั่นที่ไม่ดี

import Data.List
pcg :: Int -> Int
pcg = maximum . map length . group . intToBin

intToBin :: Int -> [Int]
intToBin 0 = []
intToBin n = n `mod` 2 : intToBin (n `div` 2)

คำอธิบาย:

intToBinแปลง int เป็นรายการของเลขฐานสอง (lsb ก่อน) groupกลุ่มลำดับต่อเนื่องกันเช่นนั้นจะกลายเป็น[1, 1, 0, 0, 0, 1] คำนวณสำหรับแต่ละรายการภายในความยาวและคืนความยาวที่ยาวที่สุด[[1, 1],[0, 0, 0],[1]]maximum . map length

แก้ไข: ขอบคุณ @xnor และ @Laikoni สำหรับการบันทึกไบต์

Pyth, 7 ไบต์

heSr8.B

รันการเข้ารหัสความยาวบนสตริงไบนารีจากนั้นจัดเรียงเพื่อให้การรันที่ยาวที่สุดมาจากนั้นจึงใช้องค์ประกอบแรก (ความยาว) ขององค์ประกอบสุดท้าย (การรันที่ยาวที่สุด) ของรายการ

ใน pseudocode:

'  S     ' sorted(
'   r8   '   run_length_encode(
'     .BQ'     bin(input()) ))  \
'he      '   [-1][0]

J , 21 ไบต์

[:>./#:#;.1~1,2~:/\#:

ลองออนไลน์!

คำอธิบาย

[:>./#:#;.1~1,2~:/\#:  Input: integer n
                   #:  Binary digits of n
              2   \    For each continuous subarray of 2 digits
               ~:/       Reduce it using not-equals
            1,         Prepend a 1 to those results
     #:                Binary digits of n
        ;.1~           Cut the binary digits at each location with a 1
       #                 Get the length of each cut
[:>./                  Reduce those lengths using maximum and return

MATLAB 71 ไบต์

m=1;a=diff(int8(dec2bin(a)));while(any(a==0)),m=m+1;a=diff(a);end;m

สิ่งนี้จะแปลงตัวแปรจำนวนเต็ม 'a' ให้เป็นอาร์เรย์ int8 แบบไบนารีจากนั้นนับจำนวนครั้งที่ผลลัพธ์จะต้องมีความแตกต่างจนกว่าจะไม่มีผลลัพธ์ในศูนย์

ฉันใหม่ที่นี่ การป้อนข้อมูลแบบนี้และแบบหนึ่งซับไลน์อนุญาตโดยกฎ PCG หรือไม่

อ็อกเทฟ 31 ไบต์

@(n)max(runlength(+dec2bin(n)))

ลองออนไลน์!

คำอธิบาย

นี่คือคำแปลของคำตอบ MATL ของฉัน @(n)max(diff(find(diff([0 +dec2bin(n) 0]))))แผนแรกของฉันคือวิธีการที่แตกต่างกันคือ แต่ปรากฎว่า Octave มีrunlengthฟังก์ชั่น (ซึ่งฉันเพิ่งค้นพบ) โดยค่าเริ่มต้นมันจะส่งออกเฉพาะอาเรย์ของระยะเวลาดังนั้นผลลัพธ์ที่ต้องการคือmaxของอาเรย์นั้น ผลลัพธ์ของdec2binซึ่งเป็นอาร์เรย์ถ่าน (สตริง) ที่มี'0'และ'1'จำเป็นต้องแปลงเป็นอาร์เรย์ที่เป็นตัวเลขโดยใช้+เพราะrunlengthคาดว่าอินพุตตัวเลข

ยูทิลิตีBash / Unix, 66 65 42 ไบต์

ขอบคุณ @DigitalTrauma สำหรับการปรับปรุงที่สำคัญ (23 ไบต์!)

dc<<<`dc -e2o?p|fold -1|uniq -c|sort -n`rp

ลองออนไลน์!

Bash (+ coreutils, + grep GNU) 33, 32 ไบต์

การแก้ไข:

• ลบ 1 ไบต์ (ลบเครื่องหมายคำพูดรอบนิพจน์grep )

แข็งแรงเล่นกอล์ฟ

dc -e2o$1p|grep -Po 1+\|0+|wc -L

อธิบาย

 #Convert to binary
 >dc -e2o893p
 1101111101

 #Place each continuous run of 1es or 0es on its own line
 >dc -e2o893p|grep -Po '1+|0+'
 11
 0
 11111
 0
 1

 #Output the length of the longest line
 >dc -e2o893p|grep -Po '1+|0+'|wc -L
 5

ลองออนไลน์!

Brachylogขนาด 9 ไบต์

$b@b:lotl

ลองออนไลน์!

คำอธิบาย

$b          List of binary digits of the input
  @b        Runs of consecutive identical digits in that list
    :lo     Order those runs by length
       tl   Output is the length of the last one

C #, 106 ไบต์

n=>{int l=1,o=0,p=0;foreach(var c in System.Convert.ToString(n,2)){o=c!=p?1:o+1;l=o>l?o:l;p=c;}return l;};

เวอร์ชันที่จัดรูปแบบ:

System.Func<int, int> f = n =>
{
    int l = 1, o = 0, p = 0;
    foreach (var c in System.Convert.ToString(n, 2))
    {
        o = c != p ? 1 : o + 1;

        l = o > l ? o : l;

        p = c;
    }

    return l;
};

และวิธีอื่นในการเข้าถึงสตริงโดยดัชนีที่ 118 ไบต์โดยลบช่องว่างออก:

System.Func<int, int> f2 = n =>
{
    var s = System.Convert.ToString(n, 2);

    int l = 1, c = 1, i = 0;

    for (; i < s.Length - 1; )
    {
        c = s[i] == s[++i] ? c + 1 : 1;
        l = l < c ? c : l;
    }

    return l;
};

Javascript, 66 ไบต์

x=>Math.max(...x.toString(2).split(/(0+|1+)/g).map(y=>y.leng‌​th))

ขอบคุณmanatworkสำหรับรหัส

คำอธิบาย

x.toString(2)

แปลงตัวเลขเป็นสตริงไบนารี

split(/(0+|1+)/g)

แยกอักขระที่แตกต่างกันทุกตัว (0 หรือ 1) (regex นี้จะจับช่องว่างเปล่า แต่สามารถละเว้นได้)

map(y=>y.length)

สำหรับแต่ละองค์ประกอบของอาร์เรย์จะมีความยาวของมันและใส่ไว้ในอาร์เรย์ที่คืน

...

แปลงอาร์เรย์เป็นรายการอาร์กิวเมนต์ ([1,2,3] -> 1,2,3)

Math.max()

รับจำนวนมากที่สุดจากการขัดแย้ง

สงสัย , 27 ไบต์

max.map#len.mstr`0+|1+`g.bn

การใช้งาน:

(max.map#len.mstr`0+|1+`g.bn)123

แปลงเป็นไบนารีจับคู่ลำดับของ 0 และ 1 รับความยาวของแต่ละคู่และได้รับสูงสุด

แบตช์ 102 ไบต์

@set/a"n=%1/2,d=%1%%2,r=1+(%3+0)*!(0%2^d),l=%4-(%4-r>>5)
@if not %n%==0 %0 %n% %d% %r% %l%
@echo %l%

คำตอบของพอร์ตของ @ edc65 %2.. %4จะว่างเปล่าในการโทรครั้งแรกดังนั้นฉันจึงต้องเขียนการแสดงออกในลักษณะที่พวกเขาจะยังคงทำงาน กรณีทั่วไปมากที่สุดคือการที่ผมต้องเขียนเป็น%3 ง่ายขึ้นเพราะมันสามารถเป็นได้หรือซึ่งมีค่าเท่ากันในฐานแปดดังนั้นทำงานที่นี่ กลายเป็นเรื่องง่ายยิ่งขึ้นเพราะฉันแค่ลบมันออกไป ใช้เพื่อเปรียบเทียบด้วยเนื่องจาก Batch ไม่มีตัวดำเนินการเปรียบเทียบ(%3+0)%2010%2%4(%4-r>>5)lrset/a

Dyalog APL ขนาด 22 ไบต์

ฟังก์ชั่นรถไฟนิรนาม

⌈/∘(≢¨⊢⊂⍨1,2≠/⊢)2⊥⍣¯1⊢

⌈/∘(... ผลลัพธ์สูงสุดของฟังก์ชั่นรถไฟนิรนามต่อไปนี้ ...

 ≢¨  นับของแต่ละคน

 ⊢⊂⍨ พาร์ติชันของอาร์กิวเมนต์ที่กำหนดโดยพาร์ติชันที่อยู่ใน

 1, คนหนึ่งเตรียมที่จะ

 2≠/ จำนวนที่ไม่เท่ากันของ

 ⊢ อาร์กิวเมนต์

) นำไปใช้กับ

2⊥⍣¯1 จากฐาน 2 ใช้ค่าลบหนึ่งครั้ง (เช่นกับฐาน 2 หนึ่งครั้ง) ถึง

⊢ อาร์กิวเมนต์

ลองใช้ออนไลน์!

Japt 15 ไบต์

2o!q¢ c ml n gJ

ทดสอบออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมดในครั้งเดียวตรวจสอบกรณีทดสอบทั้งหมดในครั้งเดียว

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

                 // Implicit: U = input integer, J = -1
2o               // Create the range [0...2), or [0,1].
  ! ¢            // Map each item Z in this range to U.s(2)
   q             //                                        .q(Z).
                 // This returns the runs of 1's and 0's in the binary
                 // representation of U, respectively.
      c          // Flatten into a single list.
        ml       // Map each item Z to Z.length.
           n gJ  // Sort the result and grab the item at index -1, or the last item.
                 // This returns the largest element in the list.
                 // Implicit: output result of last expression

R, 45 34 ไบต์

max(rle(miscFuncs::bin(scan()))$l)

แก้ไขความเข้าใจผิดที่โง่เง่าด้วย @rturnbull และ @plannapus

PowerShell , 78 74 73 ไบต์

([regex]::Matches([convert]::ToString("$args",2),'0+|1+')|% Le*|sort)[-1]

ลองออนไลน์!

Ugh วิธี. Net เหล่านั้น

นี่ใช้ regex เพื่อค้นหา (และจับคู่) ลำดับที่ต่อเนื่องกันของวัตถุและเลขศูนย์จากนั้นก็ใช้Lengthคุณสมบัติ (ด้วยรูปแบบใหม่ที่ฉันพบซึ่งใช้ชุดพารามิเตอร์ที่รู้จักกันเล็กน้อยForEach-Objectเพื่อบันทึก 1 ไบต์) ของวัตถุที่ตรงกัน เรียงลำดับพวกเขาและส่งออกล่าสุด (ใหญ่ที่สุด)

J, 27 ไบต์

>./>#&.>((1,2~:/\[)<;.1])#:

แนวทางที่แตกต่างกันเล็กน้อย (และน่าเสียดายอีกต่อไป) สำหรับคำตอบของไมล์คำตอบของไมล์

การใช้งาน:

    >./>#&.>((1,2~:/\[)<;.1])#:893
5

คำอธิบาย

>./>#&.>((1,2~:/\[)<;.1])#:
                         #: Convert to base 2
        (               )   A fork
                       ]    Previous result
         (1,2~:/\[)         Find where each new sequence begins
                   <;.1     Cut the string of integers based on where each sequence begins and box them
    #&.>                    Count under open - open each box and count the items in it
>./>                        Open all the boxes and find the maximum value