Twoim zadaniem jest, biorąc pod uwagę liczbę całkowitą bez znaku n, znaleźć największą liczbę, którą można utworzyć, usuwając pojedynczy bajt (8 kolejnych bitów) danych.

Przykład

Biorąc pod uwagę liczbę 7831, najpierw konwertujemy ją na binarną (usuwając wszelkie zera na początku):

1111010010111

Następnie znajdujemy kolejną grupę 8 bitów, które po usunięciu dają największy nowy wynik. W tym przypadku istnieją 3 rozwiązania pokazane poniżej

1111010010111
  ^      ^       
   ^      ^
    ^      ^

Usuwając to dowolne z tych zbiorów 11111, które następnie przeliczamy z powrotem na wartość dziesiętną 31dla odpowiedzi.

Przypadki testowe

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

Zasady

• Gwarantujemy, że długość bitu nbędzie większa niż 8.
• Twoje rozwiązanie powinno teoretycznie działać na dowolnej długości bitów nwiększej niż 8, ale w praktyce wymaga pracy tylko dla liczb całkowitych 255 <n <2 ¹⁶
• Dane wejściowe / wyjściowe powinny być dziesiętne.
• Możesz przesłać pełny program lub funkcję.
• To jest golf golfowy , więc wygrywa najkrótszy program (w bajtach)!

Galaretka , 6 bajtów

BḄ-8ƤṀ

Monadyczny link pobierający numer i zwracający numer.

Wypróbuj online!

W jaki sposób?

Używa miłym szybkie , Ƥopracowany przez 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 bajtów

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

Wypróbuj 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 bajtów

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

Wypróbuj online!

JavaScript (ES6), 54 bajty

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>

Działa do 2 ** 31-1. Ponieważ ktoś poprosił o nieco kręcącą się odpowiedź ...

Pyth , 21 bajtów

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

Jest to funkcja rekurencyjna (należy ją wywołać za pomocą ylub zobaczyć link).

Wypróbuj tutaj!

Mathematica, 69 bajtów

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

Wypróbuj online!

To rozwiązanie działa na duże liczby Wypróbuj online!

-3 bajty od KellyLowder

Python 3 , 68 66 60 bajtów

^{-2 bajty dzięki Mr. Xcoder!}

^{-4 bajty dzięki ovs!}

^{-2 bajty dzięki Erikowi Outgolfer!}

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

Wypróbuj online!

Wolfram Language (Mathematica) , 46 bajtów

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

Wypróbuj online!

Ta wersja obsługuje tylko dane wejściowe do 2 ⁵¹⁸ -1, w przeciwnym razie napotkamy limit wielkości stosu Mathematiki. (Granice mogą się różnić w zależności od instalacji Mathematica). Drugie rozwiązanie w tej odpowiedzi pozwala tego uniknąć.

Jak to działa

Podejście rekurencyjne oparte na następującej logice:

• Maksymalna wartość powinna być 0dla każdego wejścia mniejsza niż 256, ponieważ usunięcie bajtu z liczby zjada całą liczbę. To jest nasz podstawowy przypadek, dlatego został uwzględniony, mimo że specyfikacje obiecują nam, że nie będziemy musieli obsługiwać takich danych wejściowych.
• W przeciwnym razie bierzemy Maxdwie opcje: zjedz najniższy bajt (dzieląc się z nami danymi wejściowymi 256) lub odetnij najniższy bit, powtórz na pozostałej liczbie całkowitej i dołącz ponownie najniższy bit, gdy skończymy.

Wolfram Language (Mathematica) , 55 bajtów

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

Wypróbuj online!

Alternatywna wersja, która buduje tabelę zamiast rekurencji, więc działa dla liczb dowolnej wielkości, które Mathematica może obsłużyć.

Retina , 71 67 64 bajtów

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

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

Wypróbuj online! Link zawiera tylko szybsze przypadki testowe, aby nie nadmiernie przeciążać serwera Dennisa. Edycja: Zapisano 3 bajty dzięki @MartinEnder. Wyjaśnienie:

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

Konwertuj z dziesiętnego na dwójkowy.

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

A`_

Zbuduj listę ciągów znaków, usuwając 8 kolejnych cyfr na wszystkie możliwe sposoby.

O^`
1G`

Posortuj je w odwrotnej kolejności i wybierz pierwszą (największą).

+1`\B
:$`:
1

Konwertuj z powrotem na dziesiętne. (Zobacz wyjaśnienie @ MartinEnder .)

Java (OpenJDK 8) , 138 134 bajtów

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

Wypróbuj online!

ReRegex , 294 275 bajtów

Zaoszczędzono 19 bajtów dzięki lepszym definicjom „funkcji”

Powiedziałbym, że jest to całkiem dobre dla języka opartego tylko na Regex.

Podstawowa biblioteka lib pozwala na konwersję między jednostkową i dziesiętną (co jest potrzebne, ponieważ specyfikacja wyzwania wyraźnie określa dziesiętną), ale nie obsługuje wersji binarnej; Musiałem więc napisać to jako część skryptu, dodając do niego 120 bajtów.

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

Wypróbuj online!

Według poszczególnych regeksów.

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

Kroki

Po pierwsze, importujemy bibliotekę „podstawową”, która daje dwa wyrażenia regularne. Ten, który konwertujeu<numbers> w jedność. I taki, który konwertuje z d<unary_underlines>powrotem na dziesiętne. Wynika to z faktu, że wyzwanie wymaga IO w bazie 10.

Następnie definiujemy garść wyrażeń regularnych, które przekształcają jednoargumentowy na binarny.

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

Pierwsza z nich b(\d*):(_*)\2_b/b1$1:$2b/wyszukuje b, opcjonalnie następuje kilka cyfr binarnych, następnie a :, Następnie dowolna liczba podkreśleń, następnie dokładnie taka sama ilość podkreśleń plus jeden, a na końcu kolejnyb .

Następnie zamieniamy to na b1poprzedzone cyframi binarnymi z poprzedniej :, i tylko pierwszą połowę podkreślenia, a na koniec ostatniąb .

Sprawdza to, czy jednostka jednoargumentowa nie jest podzielna przez dwa, a jeśli tak, wstawia 1 do cyfr binarnych, a następnie dzieli ją minus jeden przez dwa.

Drugi b(\d*):(_+)\2b/b0$1:$2b/jest prawie identyczny, jednak nie sprawdza dodatkowych _, co oznacza, że ​​pasuje tylko wtedy, gdy można go podzielić przez dwa, aw tym przypadku wstawia0 zamiast niego.

Trzeci sprawdza, czy brakuje nam jednoznacznych cyfr, a jeśli tak, to usuwa dopełnienie, aby po prostu zostawić cyfry binarne.

Ostatni sprawdza, czy nigdy nie podano żadnych cyfr binarnych, i w takim przypadku po prostu wychodzi 0 .

Następna grupa Regexów, którą definiujemy, polega na konwersji plików binarnych z powrotem na jednoargumentowe i są nieco prostsze.

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

Pierwsza z tej grupy, B(_*):1/B$1$1_:/podobnie jak jej antyteza, wykrywa a B, a następnie dowolną liczbę Unary cyfr :1. Nie sprawdza dopasowaniaB tym przypadku , ponieważ szuka tylko jednej cyfry na raz. Jeśli jest to dopasowane, podwaja poprzednio dopasowaną liczbę jednoargumentowych cyfr i dodaje jedną, a następnie usuwa jedną.

Drugi B(_*):0/B$1$1:/,, jest prawie identyczny z pierwszym, z wyjątkiem dopasowań 0raczej niż a1 i nie dodaje dodatkowej jednoznacznej cyfry.

Ostatni z nich B(_*):B/$1/ sprawdza, czy nie ma już cyfr binarnych, a jeśli tak, to rozpakowuje unary. W przeciwieństwie do jego antytezy, nie wymaga specjalnego przypadku 0.

Następnie definiujemy jwyrażenia regularne, które działają jak funkcja dzielenia.

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

Pierwszy j(\d*),\1(\d)(\d{7})(\d*):/j$1$2,$1$2$3$4:,B:$1$4B/robi większość ciężkiego podnoszenia. Wyszukuje j, opcjonalnie po nich cyfry binarne, które są „inkrementatorem”, następnie przecinek, po którym następuje inkrementator, a następnie dokładnie 8 cyfr binarnych, po których następuje reszta liczby binarnej, a następnie a :. Pierwsza z 8 cyfr jest dołączana do inkrementatora, zwiększając go, a następnie wszystko oprócz tych 8 cyfr z wejścia binarnego jest dołączane po :następującym a ,. Tak więc (gdybyśmy używali 2 cyfr zamiast 8) j,1001:stałoby się j1:1001:,01wtedy j10:1001,01,11. Dodatkowo dołączone elementy tablicy są owinięte w Bs, aby przekonwertować je z powrotem na jednoargumentowe.

Drugi j(\d*),\1\d{0,7}:,?(.*)/,$2,/sprawdza, czy pozostało mniej niż 8 cyfr binarnych do sprawdzenia za inkrementatorem, a jeśli tak, usuwa wszystko inne niż tablicę owiniętą w ,s. Na przykład.,_,___,

Podczas i po utworzeniu tablicy definiujemy wyrażenia regularne porównania.

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

Pierwszy z nich ,((_+)_+),(\2),/,$1,/sprawdza przecinek, po którym następuje pewna liczba znaków podkreślenia, potem jeszcze kilka, następnie przecinek, a następnie pierwsza liczba znaków podkreślenia, niż przecinek. Następnie zastępuje go całkowitą liczbą znaków podkreślenia w pierwszym elemencie otoczonym przez ,s.

Ten ostatni ,(_+),(\1_*),/,$2,/sprawdza przecinek, po którym następuje pewna liczba znaków podkreślenia, po których następuje kolejny przecinek, następnie ta sama liczba lub więcej znaków podkreślenia i ostatni przecinek. To zamiast tego pozostawi właściwy element.

Na koniec, gdy pozostanie element pasujący w ten sposób ^,(_*),$, usuwamy otaczające go przecinki i przekształcamy z powrotem na dziesiętny przezd<> . Wtedy nie będzie już więcej wyrażeń regularnych, a wynik zostanie przedstawiony.

Dane wejściowe są początkowo umieszczane w szablonie j,b:u<(?#input)>b:, który najpierw przekształca dane dziesiętne na jednoargumentowe, np. 5-> j,b:_____b:, a następnie wynikowe jednostkowe na binarne, a j,101:następnie dzieli binarne (co nie działa w tym przykładzie), pobiera największy element, konwertuje powrót do miejsca po przecinku i gotowe.

C (gcc), 91 bajtów

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 bajty od Colera Su

Obsługuje do 2**31-1

Wypróbuj online!

Zaczyna się od niskich 8 bitów (j=0), a następnie idzie w górę, zmieniając moc wyjściową, jeśli liczba z [j,j+8)odciętymi bitami jest większa niż nasz prąd, i kontynuowana, aż x nie będzie miało bitów powyżejj+8

Galaretka , 12 bajtów

BJṡ8ḟ@€ƊịBḄṀ

Wypróbuj online!

Oszczędzone bajty dzięki Jonathanowi Allanowi !

JavaScript (ES6), 94 91 bajtów

-3 bajty dzięki Justinowi Marinerowi

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

Po prostu wyrzucam rozwiązanie oparte na łańcuchach JavaScript, ale mam nadzieję, że ktoś opublikuje osobne rozwiązanie oparte na bitach, abym mógł się czegoś nauczyć.

Moje rozwiązanie rekurencyjnie pobiera 8-bitową porcję z łańcucha, przyjmując maksymalną znalezioną wartość.

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 bajtów

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

Wypróbuj online!

+13 dla using System;

Wyobrażam sobie, że istnieje sposób na zrobienie tego bez użycia Convert. Tak czy inaczej, jestem pewien, że można to zmniejszyć.

Podziękowanie

-2 bajty dzięki 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 bajtów

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

Uruchom jako potok z -nRlub spróbuj online .

Pyth, 19 bajtów

eSmi.>>.<.BQd8d2a6l

Alternatywna odpowiedź:

eSmi.<<8.>.BQdd2a6l

Wyjaśnienie:

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)

Druga odpowiedź wykorzystuje podobne podejście, z tym wyjątkiem, że najpierw obraca się w prawo i otrzymuje wszystkie bity oprócz ostatnich 8.

MATL , 23 21 bajtów

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

Wypróbuj 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.

Niestety Bn8-:8:!+q&)produkuje tylko plastry do usunięcia, a nie resztę, którą chcielibyśmy zachować.

Java (OpenJDK 8) , 73 bajty

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

Wypróbuj online!

Oktawa , 81 80 bajtów

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

Wypróbuj online!

Jest to inne rozwiązanie niż moja pierwotna próba, oszczędzając kolejne 14 bajtów.

Kod jest podzielony w następujący sposób:

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

W szóstym wierszu liczba grup jest obliczana przez znalezienie wykładnika następnej potęgi dwóch większych niż wejściowa (liczba bitów w liczbie wejściowej) i odjęcie 7, ponieważ usuwamy 8 bitów z każdej grupy - otrzymana liczba jest przechowywane bna później.

Następnie obliczamy tablicę potęg dwóch w piątej linii, która jest wystarczająco duża dla wszystkich możliwych grup, które można usunąć. Zapisujemy to w zmiennej cna później.

W następnym wierszu w górę (czwarta linia) mnożymy dane wejściowe przez tablicę potęg dwóch (zasadniczo bitowo przesuwamy każdą liczbę w górę) i przekształcamy wynik na binarny. Jeśli weźmiemy przykład 7831, wynikiem jest tablica 2D zawierająca:

000001111010010111
000011110100101110
000111101001011100
001111010010111000
011110100101110000
111101001011100000

Jeśli następnie wycinamy środkowe 8 bitów, jest to równoważne usunięciu każdej z grup 8 bitów. Odbywa się to przez trzecią linię.

Powstała tablica jest konwertowana z powrotem na dziesiętne w drugim wierszu. Musimy również podzielić przez, caby cofnąć skalowanie, które zostało początkowo wykonane dla każdej grupy.

Wreszcie w pierwszym wierszu deklarowana jest funkcja anonimowa i obliczana jest maksymalna wartość ze wszystkich grup.

• Zaoszczędź 1 bajt, używając nextpow2(x+1)zamiastnnz(bin2dec(x))

Oryginalna próba - 120 98 95 bajtów

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

Wypróbuj online!

Kod dzieli się w następujący sposób:

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

Zasadniczo oblicza macierz zawierającą możliwe grupy wartości, które można usunąć, a następnie oblicza, co daje największą liczbę.

Działająca linia po linii, piąta linia oblicza grupy, które można usunąć. Na przykład weź 7831. Jest to liczba 13-bitowa, która daje grupom:

1111100000000
1111000000001
1110000000011
1100000000111
1000000001111
0000000011111

Wynikiem piątej linii jest dwuwymiarowa tablica logiczna, której można użyć do indeksowania.

Czwarty wiersz kodu konwertuje dane wejściowe na tablicę bitów (przedstawionych jako znaki „0” i „1”), a następnie powtarza je n-7 razy (gdzien w liczbie bitów), dając jedną linię dla każdego możliwego grupowania. Powyższa maska ​​grupy służy do usuwania każdej z możliwych grup.

W trzecim wierszu wynik jest następnie przekształcany w celu cofnięcia niechcianego spłaszczenia wynikającego z zastosowania maski grupy. Drugi wiersz konwertuje z powrotem na tablicę wynikowych liczb dziesiętnych. Pierwszy wiersz definiuje funkcję anonimową jako maksymalną wartość tablicy możliwych grup.

• Zaoszczędzono 22 bajty, generując macierz grup za pomocą matematyki.
• Zapisano 3 bajty w konwersji z ciągów binarnych na logiczną maskę grupy.

Perl 5 , 78 + 1 ( -p) = 79 bajtów

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

Wypróbuj online!

Rubinowy , 55 bajtów

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

Wypróbuj online!

Perl, 53 bajty

( use 5.10.1przeniesienie perla na poziom językowy 5.10.1 jest bezpłatny)

Podaj numer wejściowy na STDIN. W przypadku dużych liczb zabraknie pamięci, ale liczba 32-bitowa na wejściu nie jest jeszcze problemem

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