งานของคุณคือกำหนดจำนวนเต็มที่ไม่ได้ลงนามnหาจำนวนมากที่สุดซึ่งสามารถสร้างได้โดยการลบข้อมูลไบต์เดียว (8 บิตต่อเนื่อง)

ตัวอย่าง

จากจำนวนที่7831ได้เราจะแปลงเป็นไบนารี่ (ลบศูนย์นำหน้า):

1111010010111

จากนั้นเราจะพบกลุ่มที่ต่อเนื่องกัน 8 บิตซึ่งเมื่อนำออกแล้วจะให้ผลลัพธ์ใหม่ที่ใหญ่ที่สุด ในกรณีนี้มี 3 โซลูชั่นดังแสดงด้านล่าง

1111010010111
  ^      ^       
   ^      ^
    ^      ^

การลบผลตอบแทนใด ๆ เหล่านี้11111ซึ่งเราจะแปลงกลับเป็นค่าทศนิยม31สำหรับคำตอบ

กรณีทดสอบ

256        ->   1
999        ->   3
7831       ->   31
131585     ->   515
7854621    ->   31261
4294967295 ->   16777215 (if your language can handle 32 bit integers)

กฎระเบียบ

• มีการรับประกันว่าความยาวของบิตnจะมากกว่า 8
• วิธีแก้ปัญหาของคุณควรใช้กับความยาวบิตที่nมากกว่า 8 แต่ในทางปฏิบัติแล้วต้องการเพียงจำนวนเต็ม255 <n <2 ¹⁶
• อินพุต / เอาต์พุตควรเป็นทศนิยม
• คุณสามารถส่งโปรแกรมหรือฟังก์ชั่นเต็มรูปแบบ
• นี่คือโค้ดกอล์ฟดังนั้นโปรแกรมที่สั้นที่สุด (เป็นไบต์) ชนะ!

เยลลี่ 6 ไบต์

BḄ-8ƤṀ

ลิงก์ monadic ที่ใช้ตัวเลขและส่งคืนตัวเลข

ลองออนไลน์!

อย่างไร?

ใช้ดีได้อย่างรวดเร็ว , Ƥการพัฒนาโดยไมล์ ...

BḄ-8ƤṀ - Link: number
B      - convert to a binary list
    Ƥ  - for loop over some slices to be determined...
  -8   - this is a negative nilad, therefore: use overlapping outfixes of length 8
       -   (exactly what the specification asks us to inspect)
 Ḅ     -   convert from a binary list to an integer (vectorises)
     Ṁ - maximum

J , 12 ไบต์

[:>./8#.\.#:

ลองออนไลน์!

          #:     to binary
     8  \.       remove consecutive groups of eight
      #.         convert each result to decimal
  >./            maximum
[:               do nothing, this lets me avoid parentheses

Python 2 , 41 ไบต์

f=lambda n:n>>8and max(n>>8,2*f(n/2)+n%2)

ลองออนไลน์!

JavaScript (ES6), 54 ไบต์

f=(n,v=n>>8,b=1,m=0)=>b>v?m:f(n,(v^n)&b^v,b+b,v>m?v:m)

<input type=number min=256 max=2147483647 oninput=o.textContent=f(this.value)><pre id=o>

ทำงานได้ถึง 2 ** 31-1 เพราะมีคนถามหาคำตอบนิด ๆ หน่อย ๆ ...

Pyth , 21 ไบต์

L&K.>b8eS,K+*2y/b2%b2

นี่คือฟังก์ชั่นวนซ้ำ (ต้องเรียกด้วยyหรือดูลิงก์)

ลองที่นี่!

Mathematica, 69 ไบต์

Max@Array[Drop[#&@@s,#;;#+7]~FromDigits~2&,Last[s=#~RealDigits~2]-7]&

ลองออนไลน์!

การแก้ปัญหานี้ผลงานที่มีขนาดใหญ่หมายเลขลองออนไลน์!

-3 ไบต์จาก KellyLowder

Python 3 , 68 66 60 ไบต์

^{-2 ไบต์ขอบคุณMr. Xcoder!}

^{-4 ไบต์ขอบคุณovs!}

^{-2 ไบต์ขอบคุณErik the Outgolfer!}

lambda n:max(n%2**i|n>>i+8<<i for i in range(len(bin(n))-9))

ลองออนไลน์!

ภาษา Wolfram (Mathematica)ขนาด 46 ไบต์

Floor@If[#<256,0,Max[#/256,2#0[#/2]+#~Mod~2]]&

ลองออนไลน์!

รุ่นนี้สามารถจัดการอินพุตได้สูงสุด 2 ⁵¹⁸ -1 มิฉะนั้นเราจะใช้ขนาด จำกัด ของ Mathematica (ขอบเขตอาจแตกต่างกันระหว่างการติดตั้ง Mathematica) วิธีที่สองในคำตอบนี้หลีกเลี่ยง

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

วิธีการเรียกซ้ำโดยใช้ตรรกะต่อไปนี้:

• ค่าสูงสุดควรเป็น0อินพุตใด ๆ ที่น้อยกว่า256เนื่องจากการลบไบต์ออกจากจำนวนนั้นจะกินทั้งจำนวน นี่คือกรณีฐานของเราซึ่งเป็นเหตุผลว่าทำไมมันรวมอยู่ด้วยถึงแม้ว่ารายละเอียดจะสัญญากับเราว่าเราจะไม่ต้องจัดการอินพุตเหล่านั้น
• มิฉะนั้นเราจะใช้Maxสองตัวเลือก: กินไบต์ต่ำสุด (ให้เราหารด้วย256) หรือตัดออกบิตต่ำสุดหักจำนวนเต็มที่เหลือและผนวกบิตต่ำสุดเมื่อเราทำเสร็จ

ภาษา Wolfram (Mathematica) , 55 ไบต์

Max@Table[Mod[#,m=2^k]+Floor[#/m/2^8]m,{k,0,Log2@#-8}]&

ลองออนไลน์!

เวอร์ชันสำรองที่สร้างตารางแทนการเรียกซ้ำดังนั้นจึงสามารถทำงานกับตัวเลขทุกขนาดที่ Mathematica สามารถจัดการได้

Retina , 71 67 64 ไบต์

.+
$*
+`(1+)\1
$+0
01
1
.
$`_$'¶
_.{7}

A`_
O^`
1G`
+1`\B
:$`:
1

ลองออนไลน์! ลิงก์มีเฉพาะกรณีทดสอบที่เร็วกว่าเท่านั้นเพื่อมิให้เซิร์ฟเวอร์ของเดนนิสโอเวอร์โหลดเกินควร แก้ไข: บันทึกแล้ว 3 ไบต์ด้วย @MartinEnder คำอธิบาย:

.+
$*
+`(1+)\1
$+0
01
1

แปลงจากทศนิยมเป็นไบนารี

.
$`_$'¶
_.{7}

A`_

สร้างรายการของสตริงที่ได้รับโดยการลบตัวเลข 8 หลักติดต่อกันในวิธีที่เป็นไปได้ทั้งหมด

O^`
1G`

เรียงลำดับตามลำดับย้อนหลังและดำเนินการลำดับแรก (ใหญ่ที่สุด)

+1`\B
:$`:
1

แปลงกลับเป็นทศนิยม (ดูคำอธิบายของ @ MartinEnder )

Java (OpenJDK 8) , 138 134 ไบต์

i->{int l=0,m=0,x;String y=i.toString(i,2);for(;l<y.length()-7;m=x>m?x:m)x=i.valueOf(y.substring(0,l)+y.substring(l+++8),2);return m;}

ลองออนไลน์!

ReRegex , 294 275 ไบต์

บันทึก 19 ไบต์โดยใช้นิยาม 'ฟังก์ชั่น' ที่ดีขึ้น

ฉันจะบอกว่านี่เป็นสิ่งที่ดีสำหรับภาษา Regex เท่านั้น

lib พื้นฐานอนุญาตให้มีการแปลงระหว่าง Unary และทศนิยม (ซึ่งจำเป็นสำหรับความท้าทายที่ระบุอย่างชัดเจนโดยระบุเป็นทศนิยม) แต่ไม่รองรับ Binary ดังนั้นฉันจึงต้องเขียนมันเป็นส่วนหนึ่งของสคริปต์เพิ่ม 120 ไบต์ลงไป

#import base
b(\d*):(_*)\2_b/b1$1:$2b/b(\d*):(_+)\2b/b0$1:$2b/b(\d+):b/$1/b:b/0/B(_*):1/B$1$1_:/B(_*):0/B$1$1:/B(_*):B/$1/j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/j(\d*),\1\d{0,7}:,?(.*)/,$2,/,((_+)_+),(\2),/,$1,/,(_+),(\1_*),/,$2,/^,(_*),$/d<$1>/j,b:u<(?#input)>b:

ลองออนไลน์!

โดย Regexes ส่วนบุคคล

#import base
b(\d*):(_*)\2_b/b1$1:$2b/
b(\d*):(_+)\2b/b0$1:$2b/
b(\d+):b/$1/
b:b/0/
B(_*):1/B$1$1_:/
B(_*):0/B$1$1:/
B(_*):B/$1/
j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/
j(\d*),\1\d{0,7}:,?(.*)/,$2,/
,((_+)_+),(\2),/,$1,/
,(_+),(\1_*),/,$2,/
^,(_*),$/d<$1>/
j,b:u<(?#input)>b:

ขั้นตอน

ประการแรกเรานำเข้าไลบรารี 'ฐาน' ซึ่งให้สอง regexes หนึ่งซึ่งแปลงu<numbers>เป็นเอกภาพ และอีกอันหนึ่งที่แปลงd<unary_underlines>กลับเป็นทศนิยม นี่เป็นเพราะความท้าทายต้องใช้ IO ใน base10

จากนั้นเราจะกำหนดจำนวนหนึ่งของ regexes ซึ่งแปลงเอกนารีเป็นไบนารี

b(\d*):(_*)\2_b/b1$1:$2b/
b(\d*):(_+)\2b/b0$1:$2b/
b(\d+):b/$1/
b:b/0/

ครั้งแรกของเหล่านี้b(\d*):(_*)\2_b/b1$1:$2b/ค้นหาbตามด้วยตัวเลขไบนารีบางแล้วจากนั้นปริมาณของการขีดเส้นใต้ตามด้วยจำนวนเดียวกันที่แน่นอนของการขีดเส้นใต้บวกหนึ่งและสุดท้ายอีก:b

จากนั้นเราจะแทนที่ด้วยb1ตามด้วยตัวเลขไบนารีจากก่อนและเพียงแค่ช่วงครึ่งแรกของขีดและสุดท้ายสุดท้าย:b

ดังนั้นนี่จะตรวจสอบว่าเอกภาพไม่หารด้วยสองหรือไม่และถ้าเป็นเช่นนั้นจะเป็นการรวม 1 ให้เป็นเลขฐานสองแล้วแบ่งออกเป็นลบทีละสอง

อันที่สองb(\d*):(_+)\2b/b0$1:$2b/นั้นเกือบจะเป็น idendical แต่ไม่ได้ตรวจสอบสิ่งที่เพิ่มขึ้น_ซึ่งหมายความว่าจะตรงกับถ้ามันหารด้วยสองและในกรณีนี้เป็นการเตรียมการ0แทน

อันที่สามตรวจสอบว่าเราไม่มีเลขหลักเลขหรือไม่และถ้าใช่ให้ตัดการขยายออกเพื่อให้เหลือเลขฐานสอง

สุดท้ายการตรวจสอบหากมีไม่เคยได้รับตัวเลขไบนารีใด ๆ 0ที่จัดทำและในกรณีที่เพิ่งใบ

Regexes กลุ่มถัดไปที่เรากำหนดคือการแปลงไบนารีกลับเป็นเอกภาพและง่ายขึ้นเล็กน้อย

B(_*):1/B$1$1_:/
B(_*):0/B$1$1:/
B(_*):B/$1/

ครั้งแรกของกลุ่มนี้B(_*):1/B$1$1_:/มากเช่นสิ่งที่ตรงกันข้ามมันตรวจพบBตามด้วยจำนวนตัวเลขเอกใด ๆ :1แล้ว ไม่ได้ตรวจสอบการจับคู่Bในกรณีนี้เนื่องจากจะค้นหาเพียงหนึ่งหลักในแต่ละครั้ง หากตรงกับนี้มันจะเพิ่มจำนวนของเลขคู่หลักที่ตรงกันก่อนหน้านี้และเพิ่มหนึ่งหลักจากนั้นลบหนึ่งหลัก

ประการที่สองB(_*):0/B$1$1:/คือเกือบเป็นไปตามหลักแรกยกเว้นตรงกับ a 0มากกว่า1และไม่เพิ่มตัวเลขหลักเดียวเพิ่มเติม

สุดท้ายของสิ่งเหล่านี้B(_*):B/$1/ตรวจสอบว่าไม่มีเลขฐานสองอีกหรือไม่ ซึ่งแตกต่างจากสิ่งที่ตรงกันข้ามมันไม่จำเป็นต้องเป็นกรณีพิเศษ 0

ต่อไปเราจะกำหนดjregexes ซึ่งทำหน้าที่เป็นตัวแยก

j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/
j(\d*),\1\d{0,7}:,?(.*)/,$2,/

ครั้งแรกj(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/ทำส่วนใหญ่ของการยกของหนัก จะค้นหาjตามด้วยตัวเลขไบนารีซึ่งเป็น "incrementer" แล้วตามด้วยเครื่องหมายจุลภาค incrementer แล้วว่าตัวเลข 8 :หลักเลขฐานสองตามด้วยส่วนที่เหลือของเลขฐานสองที่แล้ว ครั้งแรกของ 8 หลักถูกผนวกเข้ากับ incrementer จึง incrementing มันแล้วทุกอย่าง แต่ผู้ที่ 8 หลักจากอินพุตไบนารีถูกผนวกหลังจากที่ดังต่อไปนี้: ,ดังนั้น (ถ้าเราได้ใช้ตัวเลข 2 หลักแทน 8) j,1001:จะกลายเป็นแล้วj1:1001:,01 j10:1001,01,11นอกจากนี้องค์ประกอบอาร์เรย์ที่ต่อท้ายจะถูกห่อBเป็น s เพื่อแปลงกลับเป็นเอกภาพ

อีกอันหนึ่งj(\d*),\1\d{0,7}:,?(.*)/,$2,/ตรวจสอบว่ามีเลขฐานสองเหลืออยู่น้อยกว่า 8 หลักเพื่อตรวจสอบหลังจากตัวเพิ่มหรือไม่ถ้าใช่ให้ลบทุกอย่างที่ไม่ใช่อาร์เรย์ที่ล้อมรอบด้วย,s เช่น.,_,___,

ระหว่างและหลังการสร้างอาร์เรย์เราจะกำหนด regexes การเปรียบเทียบ

,((_+)_+),(\2),/,$1,/
,(_+),(\1_*),/,$2,/

ครั้งแรกของเหล่านี้,((_+)_+),(\2),/,$1,/ตรวจสอบเครื่องหมายจุลภาคตามด้วยจำนวนของขีดล่างแล้วบางส่วนเพิ่มเติมตามด้วยเครื่องหมายจุลภาคจากนั้นจำนวนแรกขีดล่างกว่าเครื่องหมายจุลภาค จากนั้นจะแทนที่ด้วยขีดล่างทั้งหมดในองค์ประกอบแรกที่ล้อมรอบด้วย,s

หลัง,(_+),(\1_*),/,$2,/ตรวจสอบเครื่องหมายจุลภาคตามด้วยขีดล่างจำนวนหนึ่งตามด้วยเครื่องหมายจุลภาคอื่นจากนั้นจำนวนเดียวกันหรือขีดล่างมากกว่าและเครื่องหมายจุลภาคสุดท้าย สิ่งนี้จะปล่อยองค์ประกอบที่เหมาะสมไว้แทน

ในที่สุดเมื่อมีองค์ประกอบที่เหลือจึงจับคู่เราเอาเครื่องหมายจุลภาคโดยรอบและแปลงกลับไปทศนิยมผ่าน^,(_*),$ d<>จากนั้นไม่มี regexes อีกต่อไปที่สามารถยิงและแสดงผลได้

อินพุตถูกวางไว้ในเทมเพลตj,b:u<(?#input)>b:ซึ่งจะแปลงทศนิยมอินพุตเป็น unary เช่น5-> j,b:_____b:จากนั้นส่งผลให้ยูนารี่เป็นไบนารี่j,101:จากนั้นแยกไบนารี่ (ซึ่งไม่ได้ผลกับตัวอย่าง) ได้รับองค์ประกอบที่ใหญ่ที่สุดแปลง กลับไปเป็นทศนิยมและเสร็จสิ้น

C (gcc), 91ไบต์

j;m;t;f(x){for(j=m=0;t=x>>j+8;m<t?m=t:j++)t=t<<j|x%(1<<j);return m;}

-23 bytes จากColera Su

รองรับมากถึง 2**31-1

ลองออนไลน์!

เริ่มต้นด้วย 8 บิตต่ำ(j=0)จากนั้นขึ้นไปเปลี่ยนเอาต์พุตหากตัวเลขที่[j,j+8)ตัดบิตมีขนาดใหญ่กว่าของเราในปัจจุบันและดำเนินการต่อไปจนกระทั่ง x ไม่มีบิตด้านบนj+8

เยลลี่ 12 ไบต์

BJṡ8ḟ@€ƊịBḄṀ

ลองออนไลน์!

ไบต์ที่บันทึกไว้ต้องขอบคุณJonathan Allan !

JavaScript (ES6), 94 91 ไบต์

-3 ไบต์ขอบคุณ Justin Mariner

f=(n,d='',c=n.toString(2).match(`(${d}).{8}(.*)`))=>c?Math.max('0b'+c[1]+c[2],f(n,d+'.')):0

เพิ่งทิ้งโซลูชันที่ใช้สตริงของ JavaScript แต่ฉันหวังว่าจะมีใครบางคนโพสต์โซลูชันตามบิตแยกต่างหากดังนั้นฉันจึงอาจเรียนรู้บางสิ่ง

วิธีการแก้ปัญหาของฉันคว้าก้อนจำนวน 8 บิตซ้ำ ๆ จากสตริงโดยรับค่าสูงสุดที่พบ

f=(n,d='',c=n.toString(2).match(`(${d}).{8}(.*)`))=>c?Math.max('0b'+c[1]+c[2],f(n,d+'.')):0

console.log(f(256));
console.log(f(999));
console.log(f(7831));
console.log(f(131585));
console.log(f(7854621));
console.log(f(4294967295));

C # (. NET Core) , 122 + 13 = 135 120 + 13 = 133 ไบต์

n=>{int m=0,i=0,t;for(var b=Convert.ToString(n,2);i<b.Length-7;m=t>m?t:m)t=Convert.ToInt32(b.Remove(i++,8),2);return m;}

ลองออนไลน์!

+13 สำหรับ using System;

ฉันคิดว่ามีวิธีการทำเช่นนี้โดยConvertไม่ต้องใช้ ฉันแน่ใจว่ามันจะลดลง

กิตติกรรมประกาศ

-2 ไบต์ขอบคุณ Kevin Cruijssen

UnGolfed

n=>{
    int m=0,
        i=0,
        t;

    // convert n to a binary string,
    // go through removing each possible byte,
    // check if this is the biggest int so far
    for (var b=Convert.ToString(n,2); i<b.Length-7; m=t>m?t:m)
        t=Convert.ToInt32(b.Remove(i++,8),2); // remove 8 bits from position i, then convert from binary string to int

    return m;
}

PHP, 67 + 1 ไบต์

do$r=max($r,$argn&($x=2**$i++-1)|$z=$argn>>8&~$x);while($z);echo$r;

ทำงานเป็นท่อที่มี-nRหรือลองออนไลน์

Pyth, 19 ไบต์

eSmi.>>.<.BQd8d2a6l

คำตอบอื่น:

eSmi.<<8.>.BQdd2a6l

คำอธิบาย:

eSmi.>>.<.BQd8d2a6lQ | Implicit Q at the end, where Q = input
  m             a6lQ | Map the over [0, 1, 2, ... , floor(log base 2 of Q) - 7]
         .BQ         |  Convert Q to binary string
       .<   d        |  Cyclically rotate left by d
      >      8       |  Get string from position 8 to end.
    .>        d      |  Cyclically rotate right by d
   i           2     |  Convert from binary string to integer
eS                   | Find the last element of sorted list (maximum value)

คำตอบอื่น ๆ ใช้วิธีการที่คล้ายกันยกเว้นว่ามันจะหมุนไปทางขวาก่อนและได้รับบิตทั้งหมดยกเว้น 8 ล่าสุด

MATL , 23 21 ไบต์

Bn8-:"GB[]@8:q+(XBvX>

ลองออนไลน์!

B                       % Implicitly grab input, convert to binary
 n8-:                   % Create list of 1,2,... n-8, with n the size of the binary string
     "                  % Loop over this list
      GB                % Grab the input again, convert to binary once more.
        @8:q+           % Create indices of a slice of length 8
             [](        % Index into binary string, delete the slice
                XB    % Convert the remainder from binary to integer
                  vX> % Get the maximum number so far.

น่าเศร้าBn8-:8:!+q&)เพียงสร้างส่วนที่จะลบไม่ใช่ส่วนที่เหลือที่เราต้องการเก็บไว้

Java (OpenJDK 8) , 73 ไบต์

n->{int m=0,i=1;for(;i<n>>7;i*=2)m=Math.max(m,n&~-i|(n>>8&-i));return m;}

ลองออนไลน์!

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

@(x)max(bin2dec(dec2bin(x*(c=2.^(0:(b=nextpow2(x+1)-8))))(:,[1:b b+9:end]))'./c)

ลองออนไลน์!

นี่เป็นโซลูชันที่แตกต่างจากความพยายามเริ่มต้นของฉันซึ่งช่วยประหยัดอีก 14 ไบต์

รหัสถูกทำลายลงดังนี้:

@(x)max(                                                                       )
        bin2dec(                                                          )'./c
                                                         (:,[1:b b+9:end])
                dec2bin(x*(                            ))
                           c=2.^(0:                   )
                                   (b=nextpow2(x+1)-8)

ในบรรทัดที่หกจำนวนกลุ่มจะถูกคำนวณโดยการหาเลขชี้กำลังของกำลังต่อไปของสองที่มีขนาดใหญ่กว่าอินพุต (จำนวนบิตในจำนวนอินพุต) และลบ 7 ในขณะที่เรากำลังลบ 8 บิตจากแต่ละกลุ่ม - จำนวนผลลัพธ์คือ เก็บไว้ในbภายหลัง

จากนั้นเราคำนวณอาเรย์ของกำลังสองในบรรทัดที่ห้าซึ่งใหญ่พอสำหรับกลุ่มที่เป็นไปได้ทั้งหมดที่สามารถลบออกได้ เราบันทึกสิ่งนี้เป็นตัวแปรcไว้ใช้ในภายหลัง

ในบรรทัดถัดไปขึ้น (บรรทัดที่สี่) เราคูณอินพุตด้วยอาเรย์ของสอง (โดยพื้นฐานแล้วเลื่อนบิตแต่ละหมายเลขขึ้น) และแปลงผลลัพธ์เป็นไบนารี หากเรายกตัวอย่าง 7831 ผลลัพธ์นี้จะเป็นอาร์เรย์ 2 มิติที่มี:

000001111010010111
000011110100101110
000111101001011100
001111010010111000
011110100101110000
111101001011100000

ถ้าเราตัดจุดศูนย์กลาง 8 บิตนั่นเท่ากับการเอากลุ่ม 8 บิตออก สิ่งนี้ทำโดยบรรทัดที่สาม

อาร์เรย์ผลลัพธ์จะถูกแปลงกลับเป็นทศนิยมในบรรทัดที่สอง เราต้องหารด้วยcการยกเลิกการปรับขนาดที่ทำกับแต่ละกลุ่มในตอนแรก

ในที่สุดบรรทัดแรกจะมีการประกาศฟังก์ชันที่ไม่ระบุชื่อและคำนวณค่าสูงสุดจากทุกกลุ่ม

• บันทึก 1 ไบต์โดยใช้nextpow2(x+1)แทนnnz(bin2dec(x))

ความพยายามเริ่มต้น - 120 98 95 ไบต์

@(x)max(bin2dec(reshape(repmat(a=(d=@dec2bin)(x)',1,b=nnz(a)-7)(d(255*2.^(0:b-1))'<49),[],b)'))

ลองออนไลน์!

รหัสถูกแบ่งเป็นดังนี้:

@(x)max(                                                                                      )
        bin2dec(                                                                             )
                reshape(                                                              ,[],b)'
                        repmat(a=(d=@dec2bin)(x)',1,b=nnz(a)-7)(                     )
                                                                d(255*2.^(0:b-1))'<49

โดยพื้นฐานแล้วมันจะคำนวณเมทริกซ์ที่มีกลุ่มของค่าที่เป็นไปได้ที่สามารถลบออกได้

การทำงานทีละบรรทัดบรรทัดที่ห้าจะคำนวณกลุ่มที่สามารถลบออกได้ ตัวอย่างเช่นรับ 7831 นี่คือหมายเลข 13 บิตโดยให้กลุ่ม:

1111100000000
1111000000001
1110000000011
1100000000111
1000000001111
0000000011111

ผลลัพธ์ของบรรทัดที่ห้าคืออาเรย์แบบลอจิคัล 2D ซึ่งสามารถใช้สำหรับการทำดัชนี

บรรทัดที่สี่ของรหัสแปลงอินพุตเป็นอาร์เรย์ของบิต (แสดงเป็นอักขระ '0' และ '1') จากนั้นทำซ้ำn-7 ครั้ง (โดยที่nจำนวนบิต) ให้หนึ่งบรรทัดสำหรับการจัดกลุ่มแต่ละกลุ่มที่เป็นไปได้ รูปแบบกลุ่มด้านบนใช้เพื่อลบกลุ่มที่เป็นไปได้แต่ละกลุ่ม

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

• บันทึก 22 ไบต์โดยสร้างเมทริกซ์ของกลุ่มโดยใช้คณิตศาสตร์
• บันทึก 3 ไบต์ในการแปลงจากสตริงไบนารีเป็นมาส์กกลุ่มตรรกะ

Perl 5 , 78 + 1 ( -p) = 79 ไบต์

map{$\=$"if($"=oct$s=~s/.{$_}\K.{8}//r)>$\}2..length($s=sprintf'0b%b',$_)-10}{

ลองออนไลน์!

Ruby , 55 ไบต์

->n{(8../$/=~"%b"%n).map{|r|n>>8&(a=-1<<r-8)|n&~a}.max}

ลองออนไลน์!

Perl, 53 ไบต์

(the ที่use 5.10.1จะนำ Perl ไปยังระดับ lanugage 5.10.1 ฟรี)

ระบุหมายเลขอินพุตใน STDIN จะมีหน่วยความจำไม่เพียงพอสำหรับตัวเลขขนาดใหญ่ แต่ตัวเลข 32- บิตในอินพุตยังไม่เป็นปัญหา

#!/usr/bin/perl
use 5.10.1;
$_=sprintf"%b",<>;/.{8}(?{\$F[oct"0b$`$'"]})^/;say$#F