Nhiệm vụ của bạn là, được cung cấp một số nguyên không dấu n, tìm số lớn nhất có thể được tạo bằng cách xóa một byte (8 bit liên tiếp) của dữ liệu.

Thí dụ

Với số lượng 7831, trước tiên chúng tôi chuyển đổi nó thành nhị phân (loại bỏ mọi số 0 đứng đầu):

1111010010111

Sau đó, chúng tôi tìm thấy nhóm 8 bit liên tiếp, khi bị loại bỏ, sẽ mang lại kết quả mới lớn nhất. Trong trường hợp này, có 3 giải pháp, được hiển thị dưới đây

1111010010111
  ^      ^       
   ^      ^
    ^      ^

Loại bỏ điều này bất kỳ trong số những sản lượng này 11111, sau đó chúng tôi chuyển đổi trở lại giá trị thập phân của nó 31cho câu trả lời.

Các trường hợp thử nghiệm

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

Quy tắc

• Nó được đảm bảo rằng độ dài bit nsẽ lớn hơn 8.
• Về mặt lý thuyết, giải pháp của bạn sẽ hoạt động với bất kỳ độ dài bit nào nlớn hơn 8, nhưng trong thực tế, chỉ cần hoạt động cho các số nguyên 255 <n <2 ¹⁶
• Đầu vào / đầu ra phải ở dạng thập phân.
• Bạn có thể gửi một chương trình đầy đủ hoặc một chức năng.
• Đây là môn đánh gôn , vì vậy chương trình ngắn nhất (tính bằng byte) sẽ thắng!

Thạch , 6 byte

BḄ-8ƤṀ

Một liên kết đơn âm lấy một số và trả về một số.

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

Làm sao?

Sử dụng một đẹp nhanh chóng , Ƥđược phát triển bởi dặm ...

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 byte

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

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

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

Python 2 , 41 byte

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

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

JavaScript (ES6), 54 byte

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>

Hoạt động tới 2 ** 31-1. Bởi vì ai đó đã yêu cầu một câu trả lời đôi chút ...

Bình thường , 21 byte

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

Đây là một hàm đệ quy (phải được gọi với yhoặc xem liên kết).

Hãy thử nó ở đây!

Toán học, 69 byte

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

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

Giải pháp này hoạt động với số lượng lớn Hãy thử trực tuyến!

-3 byte từ KellyLowder

Python 3 , 68 66 60 byte

^{-2 byte nhờ ông Xcoder!}

^{-4 byte nhờ vào lò nướng!}

^{-2 byte nhờ Erik the Outgolfer!}

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

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

Ngôn ngữ Wolfram (Mathicala) , 46 byte

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

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

Phiên bản này chỉ có thể xử lý các đầu vào tối đa 2 ⁵¹⁸ -1, nếu không, chúng tôi chạy vào giới hạn kích thước ngăn xếp của Mathicala. (Các ràng buộc có thể khác nhau giữa các cài đặt Mathicala.) Giải pháp thứ hai trong câu trả lời này tránh điều đó.

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

Một cách tiếp cận đệ quy dựa trên logic sau:

• Giá trị tối đa phải 0dành cho bất kỳ đầu vào nào nhỏ hơn 256, vì lấy một byte ra khỏi số ăn toàn bộ số. Đây là trường hợp cơ bản của chúng tôi, đó là lý do tại sao nó được bao gồm mặc dù thông số kỹ thuật hứa với chúng tôi rằng chúng tôi sẽ không phải xử lý các đầu vào như vậy.
• Mặt khác, chúng tôi có Maxhai tùy chọn: ăn byte thấp nhất (cho chúng tôi đầu vào chia cho 256) hoặc cắt bit thấp nhất, lặp lại số nguyên còn lại và nối lại bit thấp nhất khi chúng tôi hoàn thành.

Ngôn ngữ Wolfram (Mathicala) , 55 byte

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

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

Một phiên bản thay thế xây dựng bảng thay vì đệ quy, do đó, nó hoạt động với các số có kích thước bất kỳ mà Mathicala có thể xử lý.

Võng mạc , 71 67 64 byte

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

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

Hãy thử trực tuyến! Liên kết chỉ bao gồm các trường hợp kiểm tra nhanh hơn, để không làm quá tải máy chủ của Dennis. Chỉnh sửa: Đã lưu 3 byte nhờ @MartinEnder. Giải trình:

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

Chuyển đổi từ thập phân sang nhị phân.

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

A`_

Xây dựng danh sách các chuỗi thu được bằng cách xóa 8 chữ số liên tiếp theo tất cả các cách có thể.

O^`
1G`

Sắp xếp chúng theo thứ tự ngược lại và lấy cái đầu tiên (lớn nhất).

+1`\B
:$`:
1

Chuyển đổi trở lại thập phân. (Xem phần giải thích của @ MartinEnder .)

Java (OpenJDK 8) , 138 134 byte

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

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

ReRegex , 294 275 byte

Đã lưu 19 byte bằng cách sử dụng định nghĩa 'hàm' tốt hơn

Tôi muốn nói rằng điều này là khá tốt cho một ngôn ngữ chỉ Regex.

Lib cơ sở không cho phép chuyển đổi giữa Unary và Decimal (Cần thiết là thông số thách thức nêu rõ thập phân), nhưng không hỗ trợ Binary; Vì vậy, tôi đã phải viết nó như là một phần của tập lệnh thêm 120 byte vào nó.

#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:

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

Theo chế độ cá nhân.

#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:

Các bước

Đầu tiên, chúng tôi nhập thư viện 'cơ sở', cung cấp hai biểu thức chính. Một trong đó chuyển đổi u<numbers>thành unary. Và một trong đó chuyển đổid<unary_underlines> trở lại thành số thập phân. Điều này là do thử thách yêu cầu IO trong cơ sở10.

Sau đó, chúng tôi xác định một số regexes chuyển đổi unary thành nhị phân.

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

Đầu tiên, b(\d*):(_*)\2_b/b1$1:$2b/tìm kiếm b, tùy ý theo sau bởi một số chữ số nhị phân, sau đó a :, Sau đó, bất kỳ số lượng gạch chân nào, tiếp theo là cùng một lượng gạch chân chính xác cộng với một, và cuối cùng là một số khácb .

Sau đó, chúng tôi thay thế b1bằng chữ số nhị phân từ trước :và chỉ nửa đầu của dấu gạch dưới và cuối cùng là chữ số cuối cùngb .

Vì vậy, điều này kiểm tra xem unary không chia hết cho hai hay không, và nếu vậy, hãy thêm 1 vào các chữ số nhị phân của nó, sau đó chia cho nó trừ đi hai.

Cái thứ hai, b(\d*):(_+)\2b/b0$1:$2b/gần như là ý tưởng, tuy nhiên không kiểm tra thêm _, có nghĩa là nó chỉ khớp nếu nó chia hết cho hai và trong trường hợp này là một0 thay vào đó thay thế.

Cái thứ ba kiểm tra xem chúng ta có ra các chữ số đơn nhất hay không, và nếu vậy, hãy bỏ phần đệm để chỉ để lại các chữ số nhị phân.

Cái cuối cùng kiểm tra xem có bao giờ có bất kỳ chữ số nhị phân nào được cung cấp không, và trong trường hợp đó chỉ để lại 0 .

Nhóm Regexes tiếp theo mà chúng tôi xác định là chuyển đổi nhị phân trở lại thành đơn nguyên và đơn giản hơn một chút.

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

Đầu tiên của nhóm này, B(_*):1/B$1$1_:/giống như phản đề của nó, phát hiện a B, theo sau là bất kỳ số lượng chữ số Unary nào, sau đó :1. Nó không kiểm tra sự phù hợp Btrong trường hợp này, vì nó chỉ tìm kiếm một chữ số tại một thời điểm. Nếu điều này được khớp, nó sẽ nhân đôi số lượng các chữ số đơn nguyên được khớp trước đó và thêm một chữ số, sau đó loại bỏ một chữ số.

Cái thứ hai, B(_*):0/B$1$1:/gần như là ý tưởng của cái thứ nhất, ngoại trừ khớp với một 0chứ không phải là một1 , và không thêm một chữ số unary bổ sung.

Cuối cùng trong số này, B(_*):B/$1/ kiểm tra nếu không có thêm các chữ số nhị phân, và nếu vậy sẽ hủy bỏ unary. Không giống như phản đề của nó, điều này không cần trường hợp 0 ​​đặc biệt.

Tiếp theo, chúng tôi xác định jregexes, hoạt động như một chức năng phân tách.

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

Việc đầu tiên, j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/hầu hết các nâng nặng. Nó tìm kiếm j, tùy ý theo sau là các chữ số nhị phân là "số gia", sau đó là dấu phẩy theo sau là số tăng sau đó chính xác là 8 chữ số nhị phân theo sau là phần còn lại của số nhị phân, sau đó a :. Đầu tiên trong số 8 chữ số được gắn vào bộ tăng, do đó tăng nó, sau đó mọi thứ trừ 8 chữ số từ đầu vào nhị phân được nối sau :a ,. Vì vậy, (Nếu chúng ta sử dụng 2 chữ số thay vì 8) j,1001:sẽ trở thành j1:1001:,01sau đó j10:1001,01,11. Ngoài ra, các phần tử mảng được nối được gói trong Bs, để chuyển đổi chúng thành unary.

Mặt khác, j(\d*),\1\d{0,7}:,?(.*)/,$2,/kiểm tra nếu có ít hơn 8 chữ số nhị phân còn lại để kiểm tra sau bộ tăng, và nếu vậy, sẽ loại bỏ mọi thứ khác ngoài mảng được bọc trong, s. Ví dụ.,_,___,

Trong và sau khi tạo mảng, chúng tôi xác định các biểu thức so sánh.

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

Đầu tiên, ,((_+)_+),(\2),/,$1,/kiểm tra một dấu phẩy theo sau là một số dấu gạch dưới, sau đó một số dấu phẩy, tiếp theo là dấu phẩy, sau đó là dấu phẩy đầu tiên, hơn dấu phẩy. Sau đó, nó thay thế nó bằng tổng số dấu gạch dưới trong phần tử đầu tiên được bao quanh bởi, s.

Cái sau ,(_+),(\1_*),/,$2,/ kiểm tra một dấu phẩy theo sau là một số dấu gạch dưới tiếp theo là một dấu phẩy khác, sau đó cùng một lượng hoặc nhiều dấu gạch dưới và dấu phẩy cuối cùng. Điều này thay vào đó sẽ để lại các yếu tố đúng.

Cuối cùng, khi có phần tử còn lại do đó khớp ^,(_*),$, chúng tôi xóa dấu phẩy xung quanh và chuyển trở lại thành số thập phân quad<> . Sau đó, không có nhiều regex có thể bắn và đầu ra được trình bày.

Đầu vào ban đầu được đặt vào khuôn mẫu j,b:u<(?#input)>b:, đầu tiên chuyển đổi đầu vào thập phân thành unary, ví dụ 5-> j,b:_____b:, sau đó là unary thành nhị phân, sau j,101:đó tách nhị phân (ví dụ không hoạt động), lấy phần tử lớn nhất, chuyển đổi trở lại số thập phân, và thực hiện.

C (gcc), 91 byte

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 byte từ Colera Su

Hỗ trợ lên đến 2**31-1

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

Bắt đầu với 8 bit thấp (j=0), sau đó tăng lên, thay đổi đầu ra nếu số lượng bit [j,j+8)bị cắt lớn hơn hiện tại của chúng tôi và tiếp tục cho đến khi x không có bit nào ở trênj+8

Thạch , 12 byte

BJṡ8ḟ@€ƊịBḄṀ

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

Lưu byte nhờ Jonathan Allan !

JavaScript (ES6), 94 91 byte

-3 byte nhờ Justin Mariner

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

Chỉ cần đưa ra một giải pháp dựa trên chuỗi JavaScript, nhưng tôi hy vọng ai đó sẽ đăng một giải pháp dựa trên bit riêng biệt để tôi có thể học được điều gì đó.

Giải pháp của tôi đệ quy lấy một đoạn 8 bit từ chuỗi, lấy giá trị tối đa được tìm thấy.

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 byte

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

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

+13 cho using System;

Tôi tưởng tượng có một cách để làm điều này với việc sử dụng Convert . Dù bằng cách nào, tôi chắc chắn điều này có thể được giảm bớt.

Lời cảm ơn

-2 byte nhờ Kevin Cruijssen

Vô duyên

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 byte

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

Chạy như ống với -nRhoặc thử trực tuyến .

Bình thường, 19 byte

eSmi.>>.<.BQd8d2a6l

Câu trả lời thay thế:

eSmi.<<8.>.BQdd2a6l

Giải trình:

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)

Câu trả lời khác sử dụng một cách tiếp cận tương tự, ngoại trừ việc nó xoay phải trước và nhận được tất cả các bit ngoại trừ 8 bit cuối cùng.

MATL , 23 21 byte

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

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

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.

Đáng buồn thay, Bn8-:8:!+q&)chỉ tạo ra các lát cắt được loại bỏ, không phải phần còn lại chúng tôi muốn giữ lại.

Java (OpenJDK 8) , 73 byte

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

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

Octave , 81 80 byte

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

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

Đây là một giải pháp khác với nỗ lực ban đầu của tôi, tiết kiệm thêm 14 byte.

Mã được chia nhỏ như sau:

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

Trên dòng thứ sáu, số lượng nhóm được tính bằng cách tìm số mũ của công suất tiếp theo lớn hơn hai đầu vào (số bit trong số đầu vào) và trừ 7 khi chúng tôi loại bỏ 8 bit khỏi mỗi nhóm - số kết quả là lưu trữ bcho sau này.

Sau đó, chúng tôi tính toán một loạt các quyền hạn của hai trên dòng thứ năm đủ lớn cho tất cả các nhóm có thể có thể được loại bỏ. Chúng tôi lưu điều này trong biến ccho sau này.

Trên dòng tiếp theo (dòng tiếp theo), chúng tôi nhân đầu vào với mảng lũy ​​thừa của hai (về cơ bản là dịch chuyển từng số lên) và chuyển đổi kết quả thành nhị phân. Nếu chúng ta lấy ví dụ về 7831, điều này dẫn đến một mảng 2D có chứa:

000001111010010111
000011110100101110
000111101001011100
001111010010111000
011110100101110000
111101001011100000

Nếu sau đó chúng ta cắt ra 8 bit trung tâm, điều đó tương đương với việc loại bỏ từng nhóm 8 bit. Điều này được thực hiện bởi dòng thứ ba.

Mảng kết quả được chuyển đổi trở lại thành thập phân trên dòng thứ hai. Chúng tôi cũng phải phân chia cđể hoàn tác tỷ lệ đã được thực hiện cho từng nhóm ban đầu.

Cuối cùng, trên dòng đầu tiên, một hàm ẩn danh được khai báo và giá trị tối đa từ tất cả các nhóm được tính toán.

• Lưu 1 byte bằng cách sử dụng nextpow2(x+1)thay vìnnz(bin2dec(x))

Nỗ lực ban đầu - 120 98 95 byte

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

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

Mã được chia ra như sau:

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

Về cơ bản, nó tính toán một ma trận chứa các nhóm giá trị có thể có thể được loại bỏ, và sau đó tìm ra kết quả cuối cùng cho số lớn nhất.

Dòng làm việc theo dòng, dòng thứ năm tính toán các nhóm có thể được loại bỏ. Ví dụ: lấy 7831. Đây là số 13 bit, đưa ra các nhóm:

1111100000000
1111000000001
1110000000011
1100000000111
1000000001111
0000000011111

Kết quả của dòng thứ năm là một mảng logic 2D có thể được sử dụng để lập chỉ mục.

Dòng thứ tư của mã chuyển đổi đầu vào thành một mảng các bit (được biểu thị dưới dạng các ký tự '0' và '1'), sau đó sao chép nó n-7 lần ( ntrong đó số bit) tạo một dòng cho mỗi nhóm có thể. Mặt nạ nhóm ở trên được sử dụng để loại bỏ từng nhóm có thể.

Trên dòng thứ ba, kết quả sau đó được định hình lại để hoàn tác việc làm phẳng không mong muốn do áp dụng mặt nạ nhóm. Dòng thứ hai chuyển đổi trở lại một mảng các số thập phân kết quả. Và dòng đầu tiên định nghĩa hàm ẩn danh là giá trị tối đa của mảng các nhóm có thể.

• Đã lưu 22 byte bằng cách tạo ma trận của các nhóm bằng toán học.
• Đã lưu 3 byte khi chuyển đổi từ chuỗi nhị phân sang mặt nạ nhóm logic.

Perl 5 , 78 + 1 ( -p) = 79 byte

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

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

Ruby , 55 byte

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

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

Perl, 53 byte

(việc use 5.10.1mang perl đến mức lan truyền 5.10.1 là miễn phí)

Cho số đầu vào trên STDIN. Sẽ hết bộ nhớ cho số lớn, nhưng số 32 bit trong đầu vào vẫn chưa phải là vấn đề

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