Ambil byte dari itu!

24

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 16
  • Input / Output harus dalam desimal.
  • Anda dapat mengirimkan program atau fungsi lengkap.
  • Ini adalah , jadi program terpendek (dalam byte) menang!
FlipTack
sumber
1
Saya tidak mengerti mengapa orang menaruh tanda seru di judul tantangan! Saya pikir itu mungkin hal batasan karakter! Mungkin orang-orang akan menyadari tantangannya!
dkudriavtsev
1
@Mendeleev Ini adalah kalimat keharusan. Itu biasanya diakhiri dengan tanda seru. Itu hanya tanda baca yang benar, mengapa itu membuat Anda kesal?
Arthur
1
@Mendeleev Orang sering menggunakan tanda seru untuk menunjukkan lelucon. OP menyoroti fakta bahwa dia membuat pelesetan. F. Scott Fitzgerald tidak menyukainya , tetapi dalam konteks ini, sepertinya baik bagi saya. Jika tidak ada di sana, Anda mungkin akan membuat orang mengeluh tentang ejaannya.
bornfromanegg
@Mendeleev karena itu permainan kata yang buruk ...
FlipTack
@bornfromanegg Saya merasa seperti orang akan melihat permainan kata
dkudriavtsev

Jawaban:

16

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
Jonathan Allan
sumber
> _> ... Wow Anda mengalahkan saya dengan 10 byte
Tn. Xcoder
8

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
FrownyFrog
sumber
Algoritma bagus apa yang Anda miliki di sana? Bisakah Anda menambahkan penjelasan?
Tn. Xcoder
@Bapak. Xcoder FrownyFrog mengubah angka menjadi daftar digit biner (#:), lalu mengonversi semua 8-outfixes, atau daftar dengan infiks 8-bit berturut-turut dihapus kembali ke sistem angka desimal (8 #. \.) Dan akhirnya mengambil yang terbesar. [: cukup tutup kedua kata kerja sebelumnya, dengan membuat> ./ untuk dieksekusi secara monadik (hanya dengan argumen yang benar)
Galen Ivanov
Anda mengajari saya tentang perbaikan hari ini, terima kasih untuk itu! Sayang itu tampaknya tidak lebih pendek untuk menggunakan under- &.; ini adalah jenis masalah yang sempurna untuk itu.
cole
6

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 ...

Neil
sumber
4

Pyth , 21 byte

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

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

Coba di sini!

Tuan Xcoder
sumber
3

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

J42161217
sumber
Hemat 3 byte lagi:Max[c=#~RealDigits~2;Array[Drop[c[[1]],#;;#+7]~FromDigits~2&,Last@c-7]]&
Kelly Lowder
1
@KellyLowder bagus! Saya
bermain golf
3

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 518 -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.

Misha Lavrov
sumber
2
Kedalaman rekursi terlampaui untuk angka yang lebih besar dari 10 ^ 160 meskipun Mathematica dapat menangani angka yang lebih besar. Tapi saya kira OP baik-baik saja dengan itu
J42161217
2

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 .)

Neil
sumber
1
Saya datang dengan konversi biner pendek ke desimal ini beberapa waktu lalu. Saya telah menjelaskan cara kerjanya dalam jawaban ini .
Martin Ender
2

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!

Roberto Graham
sumber
1
i.toBinaryString(i)bisa i.toString(i,2).
Kevin Cruijssen
2

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.

ATaco
sumber
2

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

pizzapants184
sumber
2
Simpan x>>j+8dan x>>j+8<<j|x%(1<<j)dalam variabel (tanda kurung dihapus) akan menguranginya menjadi 68 byte .
Colera Su
1

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.

Rick Hitchcock
sumber
1
Saya pikir Anda dapat menjatuhkan +(...)yang mengkonversi '0b'+c[1]+c[2]ke nomor, karena Math.maxsudah melakukannya. Cobalah online! ( spec untuk referensi di masa mendatang )
Justin Mariner
@JustinMariner, manis, terima kasih!
Rick Hitchcock
1

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;
}
Ayb4btu
sumber
Anda dapat menyimpan byte dengan mengubah whileto fordan meletakkannya var bdi dalamnya:for(var b=Convert.ToString(n,2);i<b.Length-7;)
Kevin Cruijssen
Dan Anda dapat menyimpan 1 byte lebih banyak dengan menambahkan variabel int baru ,tdan tidak menggunakan Math.Max, tetapi sebagai gantinya memeriksa manual: 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;}( 120 + 13 byte )
Kevin Cruijssen
1

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 .

Titus
sumber
1

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.

K Zhang
sumber
1

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.

Sanchises
sumber
Ini menghemat beberapa byte: Bn8-:"GB[]@8:q+(XBvX>(tetapkan []dengan (alih - alih menggunakan &), dan ganti &:dengan :dan penambahan)
Luis Mendo
@LuisMendo Terima kasih. Saya salah membaca dokumen, yang mengatakan di suatu tempat bahwa Anda hanya dapat menggunakan indeks tunggal untuk tugas nol, tetapi untuk situasi yang berbeda.
Sanchises
0

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.
Tom Carpenter
sumber
0

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

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

Cobalah online!

Xcali
sumber
0

Ruby , 55 byte

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

Cobalah online!

GB
sumber
0

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
Ton Hospel
sumber