Tugas Anda adalah, mengingat bilangan bulat yang tidak ditandatangani n, menemukan angka terbesar yang dapat dibuat dengan menghapus satu byte (8 bit berturut-turut) data.

Contoh

Diberi nomor tersebut 7831, pertama-tama kita mengonversinya menjadi biner (menghapus sembarang nol terkemuka):

1111010010111

Kami kemudian menemukan grup 8 bit berturut-turut yang, ketika dihapus, akan menghasilkan hasil baru terbesar. Dalam hal ini, ada 3 solusi, yang ditunjukkan di bawah ini

1111010010111
  ^      ^       
   ^      ^
    ^      ^

Menghapus salah satu dari hasil ini 11111, yang kemudian kami konversi kembali ke nilai desimal 31untuk jawabannya.

Uji Kasus

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

Aturan

• Dijamin bahwa panjang bit nakan lebih besar dari 8.
• Solusi Anda secara teoritis harus bekerja untuk setiap bit nlebih besar dari 8, tetapi dalam praktiknya, hanya perlu bekerja untuk bilangan bulat 255 <n <2 ¹⁶
• Input / Output harus dalam desimal.
• Anda dapat mengirimkan program atau fungsi lengkap.
• Ini adalah kode-golf , jadi program terpendek (dalam byte) menang!

Jelly , 6 byte

BḄ-8ƤṀ

Tautan monadik yang mengambil nomor dan mengembalikan nomor.

Cobalah online!

Bagaimana?

Menggunakan bagus cepat , Ƥyang dikembangkan oleh mil ...

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

Cobalah online!

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

Cobalah online!

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>

Bekerja hingga 2 ** 31-1. Karena seseorang meminta jawaban yang agak membingungkan ...

Pyth , 21 byte

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

Ini adalah fungsi rekursif (harus dipanggil dengan y, atau lihat tautannya).

Coba di sini!

Mathematica, 69 byte

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

Cobalah online!

Solusi ini berfungsi untuk jumlah besar. Coba online!

-3 byte dari KellyLowder

Python 3 , 68 66 60 byte

^{-2 byte terima kasih kepada Tn. Xcoder!}

^{-4 bytes terima kasih kepada ovs!}

^{-2 byte terima kasih kepada Erik the Outgolfer!}

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

Cobalah online!

Bahasa Wolfram (Mathematica) , 46 byte

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

Cobalah online!

Versi ini hanya dapat menangani input hingga 2 ⁵¹⁸ -1, jika tidak kita akan memasuki batas ukuran tumpukan Mathematica. (Batasnya dapat bervariasi antara instalasi Mathematica.) Solusi kedua dalam jawaban ini menghindari itu.

Bagaimana itu bekerja

Pendekatan rekursif berdasarkan logika berikut:

• Nilai maksimal harus 0untuk setiap input yang kurang dari 256, karena mengeluarkan byte dari angka memakan seluruh angka. Ini adalah kasus dasar kami, itulah sebabnya mengapa disertakan meskipun spesifikasi menjanjikan kami bahwa kami tidak perlu menangani input seperti itu.
• Kalau tidak, kita mengambil Maxdua opsi: makan byte terendah (memberi kita input dibagi dengan 256) atau memotong bit terendah, berulang pada integer yang tersisa, dan menambahkan bit terendah kembali ketika kita selesai.

Bahasa Wolfram (Mathematica) , 55 byte

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

Cobalah online!

Versi alternatif yang membangun tabel alih-alih rekursi, sehingga berfungsi untuk angka dengan ukuran berapa pun yang dapat ditangani oleh Mathematica.

Retina , 71 67 64 byte

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

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

Cobalah online! Tautan hanya mencakup test case yang lebih cepat, sehingga tidak terlalu membebani server Dennis. Sunting: Disimpan 3 byte berkat @MartinEnder. Penjelasan:

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

Konversi dari desimal ke biner.

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

A`_

Buat daftar string yang diperoleh dengan menghapus 8 digit berurutan dengan semua cara yang mungkin.

O^`
1G`

Sortir dalam urutan terbalik dan ambil yang pertama (terbesar).

+1`\B
:$`:
1

Konversi kembali ke desimal. (Lihat penjelasan @ 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;}

Cobalah online!

ReRegex , 294 275 byte

Disimpan 19 byte dengan menggunakan definisi 'fungsi' yang lebih baik

Saya akan mengatakan ini cukup baik untuk bahasa Regex saja.

Lib dasar memang memungkinkan untuk konversi antara Unary dan Desimal (Yang diperlukan sebagai spec tantangan secara eksplisit menyatakan desimal), tetapi tidak mendukung Binary; Jadi saya harus menulis itu sebagai bagian dari skrip yang menambahkan 120 byte ke dalamnya.

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

Cobalah online!

Dengan Regex Individual.

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

Tangga

Pertama, kami mengimpor perpustakaan 'basis', yang memberikan dua regex. Yang dikonversi u<numbers>menjadi unary. Dan yang bertobatd<unary_underlines> kembali menjadi desimal. Ini karena tantangannya membutuhkan IO di base10.

Kemudian kita mendefinisikan beberapa regex yang mengubah unary menjadi biner.

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

Yang pertama dari ini, b(\d*):(_*)\2_b/b1$1:$2b/mencari b, secara opsional diikuti oleh beberapa digit biner, lalu a :, Kemudian jumlah garis bawah, diikuti oleh jumlah garis bawah yang sama persis ditambah satu, dan akhirnya yang lain b.

Kami kemudian menggantinya dengan b1diikuti oleh angka-angka biner dari sebelumnya :,, dan hanya setengah dari garis bawah, dan akhirnya yang terakhir b.

Jadi ini memeriksa jika unary tidak dapat dibagi dua, dan jika demikian, menambahkan 1 ke angka binernya, kemudian membaginya menjadi minus satu per dua.

Yang kedua, b(\d*):(_+)\2b/b0$1:$2b/hampir idendis, namun tidak memeriksa untuk tambahan _, artinya hanya cocok jika dapat dibagi dua, dan dalam hal ini 0sebaliknya menambahkan .

Yang ketiga memeriksa apakah kita kehabisan digit unary, dan jika demikian, lepaskan bantalan untuk meninggalkan digit biner.

Yang terakhir memeriksa apakah tidak pernah ada digit biner yang disediakan, dan dalam kasus itu hanya pergi 0.

Kelompok Regex berikutnya yang kami definisikan adalah untuk mengubah biner kembali menjadi unary, dan sedikit lebih sederhana.

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

Yang pertama dari kelompok ini, B(_*):1/B$1$1_:/seperti halnya antitesisnya, mendeteksi a B, diikuti oleh sejumlah digit Unary, kemudian :1. Itu tidak memeriksa kecocokan Bdalam kasus ini, karena hanya mencari satu digit pada suatu waktu. Jika ini cocok, itu menggandakan jumlah digit unary yang sebelumnya cocok dan menambahkan satu, lalu menghapus satu.

Yang kedua,, B(_*):0/B$1$1:/hampir idendisikal dengan yang pertama, kecuali cocok dengan yang 0bukan 1, dan tidak menambahkan digit unary tambahan.

Yang terakhir ini,, B(_*):B/$1/periksa apakah tidak ada lagi angka biner, dan jika demikian membuka bungkusan yang unary. Tidak seperti antitesisnya, ini tidak memerlukan 0 kasus khusus.

Selanjutnya kita mendefinisikan jregex, yang bertindak sebagai fungsi pemisahan.

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

Yang pertama, j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/lakukan sebagian besar angkat berat. Ia mencari j, secara opsional diikuti oleh digit biner yang merupakan "incrementer", kemudian koma diikuti oleh incrementer kemudian tepat 8 digit biner diikuti oleh sisa nomor biner, kemudian a :. Yang pertama dari 8 digit ditambahkan ke incrementer, sehingga menambahnya, lalu semuanya kecuali 8 digit dari input biner ditambahkan setelah :berikut ini a ,. Jadi (Jika kita menggunakan 2 digit, bukan 8) j,1001:akan menjadi j1:1001:,01itu j10:1001,01,11. Selain itu, elemen array yang ditambahkan dibungkus dengan Bs, untuk mengubahnya kembali menjadi unary.

Yang lain, j(\d*),\1\d{0,7}:,?(.*)/,$2,/memeriksa apakah ada kurang dari 8 digit biner yang tersisa untuk memeriksa setelah incrementer, dan jika demikian, menghapus segala sesuatu selain array yang dibungkus dengan ,s. Misalnya.,_,___,

Selama dan setelah pembuatan array, kami mendefinisikan regex perbandingan.

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

Yang pertama, ,((_+)_+),(\2),/,$1,/periksa koma diikuti oleh sejumlah garis bawah, lalu beberapa lagi, diikuti oleh koma, lalu jumlah garis bawah pertama, daripada koma. Kemudian menggantinya dengan jumlah total garis bawah pada elemen pertama yang dikelilingi oleh ,s.

Yang terakhir,, ,(_+),(\1_*),/,$2,/memeriksa koma diikuti oleh sejumlah garis bawah diikuti oleh koma lain, kemudian jumlah yang sama atau lebih garis bawah, dan koma terakhir. Ini sebagai gantinya akan meninggalkan elemen yang tepat.

Akhirnya, ketika ada pada elemen yang tersisa sehingga cocok ^,(_*),$, kami menghapus koma sekitarnya dan mengkonversi kembali ke desimal via d<>. Maka tidak ada lagi regex yang dapat diaktifkan dan hasilnya ditampilkan.

Input awalnya ditempatkan ke dalam template j,b:u<(?#input)>b:, yang pertama-tama mengubah input desimal menjadi unary, misalnya 5-> j,b:_____b:, kemudian unary yang dihasilkan ke biner, j,101:Kemudian membelah biner (yang tidak berfungsi misalnya), mendapatkan elemen terbesar, mengkonversi kembali ke desimal, dan selesai.

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 dari Colera Su

Mendukung hingga 2**31-1

Cobalah online!

Mulai dengan 8 bit rendah (j=0), lalu naik, mengubah output jika jumlah dengan bit yang [j,j+8)dipotong lebih besar dari arus kita, dan berlanjut sampai x tidak memiliki bit di atasj+8

Jelly , 12 byte

BJṡ8ḟ@€ƊịBḄṀ

Cobalah online!

Bytes yang disimpan berkat Jonathan Allan !

JavaScript (ES6), 94 91 byte

-3 byte terima kasih kepada Justin Mariner

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

Hanya membuang solusi berbasis string JavaScript, tapi saya berharap seseorang akan memposting solusi berbasis bitwise yang terpisah sehingga saya dapat belajar sesuatu.

Solusi saya secara rekursif mengambil potongan 8-bit dari string, mengambil nilai maksimum yang ditemukan.

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

Cobalah online!

+13 untuk using System;

Saya membayangkan ada cara melakukan ini tanpa menggunakan Convert. Either way, saya yakin ini bisa dikurangi.

Ucapan Terima Kasih

-2 byte terima kasih kepada Kevin Cruijssen

Tidak disatukan

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;

Jalankan sebagai pipa dengan -nRatau coba online .

Pyth, 19 byte

eSmi.>>.<.BQd8d2a6l

Jawaban alternatif:

eSmi.<<8.>.BQdd2a6l

Penjelasan:

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)

Jawaban lainnya menggunakan pendekatan yang sama, kecuali bahwa itu berputar pertama kali, dan mendapatkan semua bit kecuali 8 terakhir.

MATL , 23 21 byte

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

Cobalah online!

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.

Sayangnya, Bn8-:8:!+q&)hanya menghasilkan irisan yang akan dihapus, bukan sisanya yang ingin kita simpan.

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

Cobalah online!

Oktaf , 81 80 byte

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

Cobalah online!

Ini adalah solusi berbeda untuk upaya awal saya, menghemat 14 byte lebih lanjut.

Kode dipecah sebagai berikut:

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

Pada baris keenam jumlah kelompok dihitung dengan menemukan eksponen kekuatan berikutnya dari dua yang lebih besar dari input (jumlah bit dalam jumlah input), dan mengurangi 7 karena kami menghapus 8 bit dari masing-masing kelompok - jumlah yang dihasilkan adalah disimpan di b untuk nanti.

Kami kemudian menghitung array kekuatan dua di baris kelima yang cukup besar untuk semua grup yang mungkin dapat dihapus. Kami menyimpan ini dalam variabelc untuk nanti.

Pada baris berikutnya ke atas (baris keempat), kita mengalikan input dengan larik pangkat dua (pada dasarnya bit menggeser setiap nomor ke atas), dan mengonversi hasilnya menjadi biner. Jika kita mengambil contoh 7831, ini menghasilkan array 2D yang berisi:

000001111010010111
000011110100101110
000111101001011100
001111010010111000
011110100101110000
111101001011100000

Jika kemudian kita memotong pusat 8 bit, itu sama dengan menghapus masing-masing kelompok 8 bit. Ini dilakukan oleh baris ketiga.

Array yang dihasilkan dikonversi kembali ke desimal pada baris kedua. Kita juga harus membaginyac untuk membatalkan penskalaan yang dilakukan untuk masing-masing kelompok pada awalnya.

Akhirnya pada baris pertama fungsi anonim dideklarasikan, dan nilai maksimum dari semua grup dihitung.

• Hemat 1 byte dengan menggunakan nextpow2(x+1)daripadannz(bin2dec(x))

Upaya asli - 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)'))

Cobalah online!

Kode ini dibagi sebagai berikut:

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

Pada dasarnya ia menghitung matriks yang berisi kelompok nilai-nilai yang mungkin dapat dihapus, dan kemudian bekerja yang akhirnya memberikan jumlah terbesar.

Bekerja baris demi baris, baris kelima menghitung kelompok yang bisa dihapus. Misalnya, ambil 7831. Ini adalah angka 13bit, memberikan grup:

1111100000000
1111000000001
1110000000011
1100000000111
1000000001111
0000000011111

Hasil dari baris kelima adalah array logis 2D yang dapat digunakan untuk pengindeksan.

Baris keempat dari kode mengubah input ke array bit (diwakili sebagai karakter '0' dan '1'), dan kemudian mereplikasi n-7 kali ( ndi mana dalam jumlah bit) memberikan satu baris untuk setiap pengelompokan yang mungkin. Topeng grup di atas digunakan untuk menghapus masing-masing grup yang mungkin.

Pada baris ketiga, hasilnya kemudian dibentuk kembali untuk membatalkan perataan yang tidak diinginkan yang dihasilkan dari penerapan topeng grup. Baris kedua mengkonversi kembali ke array angka desimal yang dihasilkan. Dan baris pertama mendefinisikan fungsi anonim menjadi nilai maksimum array dari grup yang mungkin.

• Disimpan 22 byte dengan menghasilkan matriks grup menggunakan matematika.
• Disimpan 3 byte dalam konversi dari string biner ke mask grup logis.

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

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

Cobalah online!

Ruby , 55 byte

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

Cobalah online!

Perl, 53 byte

(itu use 5.10.1 untuk membawa perl ke level bahasa 5.10.1 gratis)

Berikan nomor input pada STDIN. Akan kehabisan memori untuk nomor besar, tetapi nomor 32-bit dalam input belum menjadi masalah

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